{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.MessageHeadersIter
(
MessageHeadersIter(..) ,
newZeroMessageHeadersIter ,
#if defined(ENABLE_OVERLOADING)
ResolveMessageHeadersIterMethod ,
#endif
messageHeadersIterInit ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersIterNextMethodInfo ,
#endif
messageHeadersIterNext ,
) 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.GHashTable as B.GHT
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.Kind as DK
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 {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders
newtype = (SP.ManagedPtr MessageHeadersIter)
deriving (MessageHeadersIter -> MessageHeadersIter -> Bool
(MessageHeadersIter -> MessageHeadersIter -> Bool)
-> (MessageHeadersIter -> MessageHeadersIter -> Bool)
-> Eq MessageHeadersIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageHeadersIter -> MessageHeadersIter -> Bool
== :: MessageHeadersIter -> MessageHeadersIter -> Bool
$c/= :: MessageHeadersIter -> MessageHeadersIter -> Bool
/= :: MessageHeadersIter -> MessageHeadersIter -> Bool
Eq)
instance SP.ManagedPtrNewtype MessageHeadersIter where
toManagedPtr :: MessageHeadersIter -> ManagedPtr MessageHeadersIter
toManagedPtr (MessageHeadersIter ManagedPtr MessageHeadersIter
p) = ManagedPtr MessageHeadersIter
p
instance BoxedPtr MessageHeadersIter where
boxedPtrCopy :: MessageHeadersIter -> IO MessageHeadersIter
boxedPtrCopy = \MessageHeadersIter
p -> MessageHeadersIter
-> (Ptr MessageHeadersIter -> IO MessageHeadersIter)
-> IO MessageHeadersIter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MessageHeadersIter
p (Int -> Ptr MessageHeadersIter -> IO (Ptr MessageHeadersIter)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr MessageHeadersIter -> IO (Ptr MessageHeadersIter))
-> (Ptr MessageHeadersIter -> IO MessageHeadersIter)
-> Ptr MessageHeadersIter
-> IO MessageHeadersIter
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr MessageHeadersIter -> MessageHeadersIter)
-> Ptr MessageHeadersIter -> IO MessageHeadersIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr MessageHeadersIter -> MessageHeadersIter
MessageHeadersIter)
boxedPtrFree :: MessageHeadersIter -> IO ()
boxedPtrFree = \MessageHeadersIter
x -> MessageHeadersIter -> (Ptr MessageHeadersIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr MessageHeadersIter
x Ptr MessageHeadersIter -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr MessageHeadersIter where
boxedPtrCalloc :: IO (Ptr MessageHeadersIter)
boxedPtrCalloc = Int -> IO (Ptr MessageHeadersIter)
forall a. Int -> IO (Ptr a)
callocBytes Int
24
newZeroMessageHeadersIter :: MonadIO m => m MessageHeadersIter
= IO MessageHeadersIter -> m MessageHeadersIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeadersIter -> m MessageHeadersIter)
-> IO MessageHeadersIter -> m MessageHeadersIter
forall a b. (a -> b) -> a -> b
$ IO (Ptr MessageHeadersIter)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr MessageHeadersIter)
-> (Ptr MessageHeadersIter -> IO MessageHeadersIter)
-> IO MessageHeadersIter
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr MessageHeadersIter -> MessageHeadersIter)
-> Ptr MessageHeadersIter -> IO MessageHeadersIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MessageHeadersIter -> MessageHeadersIter
MessageHeadersIter
instance tag ~ 'AttrSet => Constructible MessageHeadersIter tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr MessageHeadersIter -> MessageHeadersIter)
-> [AttrOp MessageHeadersIter tag] -> m MessageHeadersIter
new ManagedPtr MessageHeadersIter -> MessageHeadersIter
_ [AttrOp MessageHeadersIter tag]
attrs = do
MessageHeadersIter
o <- m MessageHeadersIter
forall (m :: * -> *). MonadIO m => m MessageHeadersIter
newZeroMessageHeadersIter
MessageHeadersIter -> [AttrOp MessageHeadersIter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set MessageHeadersIter
o [AttrOp MessageHeadersIter tag]
[AttrOp MessageHeadersIter 'AttrSet]
attrs
MessageHeadersIter -> m MessageHeadersIter
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeadersIter
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MessageHeadersIter
type instance O.AttributeList MessageHeadersIter = MessageHeadersIterAttributeList
type MessageHeadersIterAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "soup_message_headers_iter_next" ::
Ptr MessageHeadersIter ->
Ptr CString ->
Ptr CString ->
IO CInt
messageHeadersIterNext ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeadersIter
-> m ((Bool, T.Text, T.Text))
MessageHeadersIter
iter = IO (Bool, Text, Text) -> m (Bool, Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Text) -> m (Bool, Text, Text))
-> IO (Bool, Text, Text) -> m (Bool, Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeadersIter
iter' <- MessageHeadersIter -> IO (Ptr MessageHeadersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeadersIter
iter
Ptr CString
name <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr MessageHeadersIter -> Ptr CString -> Ptr CString -> IO CInt
soup_message_headers_iter_next Ptr MessageHeadersIter
iter' Ptr CString
name Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
name' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
name
Text
name'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name'
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
MessageHeadersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeadersIter
iter
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
name
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text, Text) -> IO (Bool, Text, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
name'', Text
value'')
#if defined(ENABLE_OVERLOADING)
data MessageHeadersIterNextMethodInfo
instance (signature ~ (m ((Bool, T.Text, T.Text))), MonadIO m) => O.OverloadedMethod MessageHeadersIterNextMethodInfo MessageHeadersIter signature where
overloadedMethod = messageHeadersIterNext
instance O.OverloadedMethodInfo MessageHeadersIterNextMethodInfo MessageHeadersIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeadersIter.messageHeadersIterNext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeadersIter.html#v:messageHeadersIterNext"
})
#endif
foreign import ccall "soup_message_headers_iter_init" ::
Ptr MessageHeadersIter ->
Ptr Soup.MessageHeaders.MessageHeaders ->
IO ()
messageHeadersIterInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Soup.MessageHeaders.MessageHeaders
-> m (MessageHeadersIter)
MessageHeaders
hdrs = IO MessageHeadersIter -> m MessageHeadersIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeadersIter -> m MessageHeadersIter)
-> IO MessageHeadersIter -> m MessageHeadersIter
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeadersIter
iter <- Int -> IO (Ptr MessageHeadersIter)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr MessageHeadersIter)
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeadersIter -> Ptr MessageHeaders -> IO ()
soup_message_headers_iter_init Ptr MessageHeadersIter
iter Ptr MessageHeaders
hdrs'
MessageHeadersIter
iter' <- ((ManagedPtr MessageHeadersIter -> MessageHeadersIter)
-> Ptr MessageHeadersIter -> IO MessageHeadersIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MessageHeadersIter -> MessageHeadersIter
MessageHeadersIter) Ptr MessageHeadersIter
iter
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
MessageHeadersIter -> IO MessageHeadersIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeadersIter
iter'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMessageHeadersIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveMessageHeadersIterMethod "next" o = MessageHeadersIterNextMethodInfo
ResolveMessageHeadersIterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMessageHeadersIterMethod t MessageHeadersIter, O.OverloadedMethod info MessageHeadersIter p) => OL.IsLabel t (MessageHeadersIter -> 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 ~ ResolveMessageHeadersIterMethod t MessageHeadersIter, O.OverloadedMethod info MessageHeadersIter p, R.HasField t MessageHeadersIter p) => R.HasField t MessageHeadersIter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMessageHeadersIterMethod t MessageHeadersIter, O.OverloadedMethodInfo info MessageHeadersIter) => OL.IsLabel t (O.MethodProxy info MessageHeadersIter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif