{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Objects.ContentSniffer
    ( 

-- * Exported types
    ContentSniffer(..)                      ,
    IsContentSniffer                        ,
    toContentSniffer                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveContentSnifferMethod             ,
#endif


-- ** getBufferSize #method:getBufferSize#

#if defined(ENABLE_OVERLOADING)
    ContentSnifferGetBufferSizeMethodInfo   ,
#endif
    contentSnifferGetBufferSize             ,


-- ** new #method:new#

    contentSnifferNew                       ,


-- ** sniff #method:sniff#

#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.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 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

-- | Memory-managed wrapper type.
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

-- | Convert 'ContentSniffer' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ContentSniffer where
    toGValue :: ContentSniffer -> IO GValue
toGValue ContentSniffer
o = do
        GType
gtype <- IO GType
c_soup_content_sniffer_get_type
        ContentSniffer -> (Ptr ContentSniffer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContentSniffer
o (GType
-> (GValue -> Ptr ContentSniffer -> IO ())
-> Ptr ContentSniffer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ContentSniffer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO ContentSniffer
fromGValue GValue
gv = do
        Ptr ContentSniffer
ptr <- GValue -> IO (Ptr ContentSniffer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ContentSniffer)
        (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
        
    

-- | Type class for types which can be safely cast to `ContentSniffer`, for instance with `toContentSniffer`.
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]

-- | Cast to `ContentSniffer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toContentSniffer :: (MonadIO m, IsContentSniffer o) => o -> m ContentSniffer
toContentSniffer :: o -> m ContentSniffer
toContentSniffer = IO ContentSniffer -> m ContentSniffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr ContentSniffer -> ContentSniffer
ContentSniffer

#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.MethodInfo 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

#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

-- method ContentSniffer::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "ContentSniffer" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_content_sniffer_new" soup_content_sniffer_new :: 
    IO (Ptr ContentSniffer)

-- | Creates a new t'GI.Soup.Objects.ContentSniffer.ContentSniffer'.
-- 
-- /Since: 2.28/
contentSnifferNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ContentSniffer
    -- ^ __Returns:__ a new t'GI.Soup.Objects.ContentSniffer.ContentSniffer'
contentSnifferNew :: 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

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

foreign import ccall "soup_content_sniffer_get_buffer_size" soup_content_sniffer_get_buffer_size :: 
    Ptr ContentSniffer ->                   -- sniffer : TInterface (Name {namespace = "Soup", name = "ContentSniffer"})
    IO Word64

-- | Gets the number of bytes /@sniffer@/ needs in order to properly sniff
-- a buffer.
-- 
-- /Since: 2.28/
contentSnifferGetBufferSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSniffer a) =>
    a
    -- ^ /@sniffer@/: a t'GI.Soup.Objects.ContentSniffer.ContentSniffer'
    -> m Word64
    -- ^ __Returns:__ the number of bytes to sniff
contentSnifferGetBufferSize :: 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.MethodInfo ContentSnifferGetBufferSizeMethodInfo a signature where
    overloadedMethod = contentSnifferGetBufferSize

#endif

-- method ContentSniffer::sniff
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "sniffer"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ContentSniffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupContentSniffer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message to sniff"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a buffer containing the start of @msg's response body"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return\n  location for Content-Type parameters (eg, \"charset\"), or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_content_sniffer_sniff" soup_content_sniffer_sniff :: 
    Ptr ContentSniffer ->                   -- sniffer : TInterface (Name {namespace = "Soup", name = "ContentSniffer"})
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr Soup.Buffer.Buffer ->               -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    Ptr (Ptr (GHashTable CString CString)) -> -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CString

-- | Sniffs /@buffer@/ to determine its Content-Type. The result may also
-- be influenced by the Content-Type declared in /@msg@/\'s response
-- headers.
-- 
-- /Since: 2.28/
contentSnifferSniff ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSniffer a, Soup.Message.IsMessage b) =>
    a
    -- ^ /@sniffer@/: a t'GI.Soup.Objects.ContentSniffer.ContentSniffer'
    -> b
    -- ^ /@msg@/: the message to sniff
    -> Soup.Buffer.Buffer
    -- ^ /@buffer@/: a buffer containing the start of /@msg@/\'s response body
    -> m ((T.Text, Map.Map T.Text T.Text))
    -- ^ __Returns:__ the sniffed Content-Type of /@buffer@/; this will never be 'P.Nothing',
    --   but may be \"application\/octet-stream\".
contentSnifferSniff :: 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.MethodInfo ContentSnifferSniffMethodInfo a signature where
    overloadedMethod = contentSnifferSniff

#endif