{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addFeature]("GI.Soup.Interfaces.SessionFeature#g:method:addFeature"), [attach]("GI.Soup.Interfaces.SessionFeature#g:method:attach"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [detach]("GI.Soup.Interfaces.SessionFeature#g:method:detach"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasFeature]("GI.Soup.Interfaces.SessionFeature#g:method:hasFeature"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeFeature]("GI.Soup.Interfaces.SessionFeature#g:method:removeFeature"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sniff]("GI.Soup.Objects.ContentSniffer#g:method:sniff"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBufferSize]("GI.Soup.Objects.ContentSniffer#g:method:getBufferSize"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

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

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

-- | 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 :: (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

-- | Convert 'ContentSniffer' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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