ContentSniffer.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.Soup.Objects.ContentSniffer
    ( 

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


 -- * Methods
-- ** getBufferSize #method:getBufferSize#

#if ENABLE_OVERLOADING
    ContentSnifferGetBufferSizeMethodInfo   ,
#endif
    contentSnifferGetBufferSize             ,


-- ** new #method:new#

    contentSnifferNew                       ,


-- ** sniff #method:sniff#

#if 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.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.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 (ManagedPtr ContentSniffer)
foreign import ccall "soup_content_sniffer_get_type"
    c_soup_content_sniffer_get_type :: IO GType

instance GObject ContentSniffer where
    gobjectType = c_soup_content_sniffer_get_type
    

-- | Type class for types which can be safely cast to `ContentSniffer`, for instance with `toContentSniffer`.
class (GObject o, O.IsDescendantOf ContentSniffer o) => IsContentSniffer o
instance (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 = liftIO . unsafeCastTo ContentSniffer

-- | A convenience alias for `Nothing` :: `Maybe` `ContentSniffer`.
noContentSniffer :: Maybe ContentSniffer
noContentSniffer = Nothing

#if 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 "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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList ContentSniffer
type instance O.AttributeList ContentSniffer = ContentSnifferAttributeList
type ContentSnifferAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if 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 'GI.Soup.Objects.ContentSniffer.ContentSniffer'.

/Since: 2.28/
-}
contentSnifferNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ContentSniffer
    {- ^ __Returns:__ a new 'GI.Soup.Objects.ContentSniffer.ContentSniffer' -}
contentSnifferNew  = liftIO $ do
    result <- soup_content_sniffer_new
    checkUnexpectedReturnNULL "contentSnifferNew" result
    result' <- (wrapObject ContentSniffer) result
    return result'

#if 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 'GI.Soup.Objects.ContentSniffer.ContentSniffer' -}
    -> m Word64
    {- ^ __Returns:__ the number of bytes to sniff -}
contentSnifferGetBufferSize sniffer = liftIO $ do
    sniffer' <- unsafeManagedPtrCastPtr sniffer
    result <- soup_content_sniffer_get_buffer_size sniffer'
    touchManagedPtr sniffer
    return result

#if 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 '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 'Nothing',
  but may be \"application\/octet-stream\". -}
contentSnifferSniff sniffer msg buffer = liftIO $ do
    sniffer' <- unsafeManagedPtrCastPtr sniffer
    msg' <- unsafeManagedPtrCastPtr msg
    buffer' <- unsafeManagedPtrGetPtr buffer
    params <- allocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
    result <- soup_content_sniffer_sniff sniffer' msg' buffer' params
    checkUnexpectedReturnNULL "contentSnifferSniff" result
    result' <- cstringToText result
    freeMem result
    params' <- peek params
    params'' <- unpackGHashTable params'
    let params''' = mapFirst cstringUnpackPtr params''
    params'''' <- mapFirstA cstringToText params'''
    let params''''' = mapSecond cstringUnpackPtr params''''
    params'''''' <- mapSecondA cstringToText params'''''
    let params''''''' = Map.fromList params''''''
    unrefGHashTable params'
    touchManagedPtr sniffer
    touchManagedPtr msg
    touchManagedPtr buffer
    freeMem params
    return (result', params''''''')

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