{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An opaque type used to iterate over a @/SoupMessageHeaders/@
-- structure.
-- 
-- After intializing the iterator with
-- 'GI.Soup.Functions.messageHeadersIterInit', call
-- 'GI.Soup.Structs.MessageHeadersIter.messageHeadersIterNext' to fetch data from it.
-- 
-- You may not modify the headers while iterating over them.

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

module GI.Soup.Structs.MessageHeadersIter
    ( 

-- * Exported types
    MessageHeadersIter(..)                  ,
    newZeroMessageHeadersIter               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [next]("GI.Soup.Structs.MessageHeadersIter#g:method:next").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveMessageHeadersIterMethod         ,
#endif

-- ** init #method:init#

    messageHeadersIterInit                  ,


-- ** next #method:next#

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

-- | Memory-managed wrapper type.
newtype MessageHeadersIter = MessageHeadersIter (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


-- | Construct a `MessageHeadersIter` struct initialized to zero.
newZeroMessageHeadersIter :: MonadIO m => m MessageHeadersIter
newZeroMessageHeadersIter :: forall (m :: * -> *). MonadIO m => m MessageHeadersIter
newZeroMessageHeadersIter = 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, *)])
#endif

-- method MessageHeadersIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MessageHeadersIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a %SoupMessageHeadersIter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "pointer to a variable to return\nthe header name in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "pointer to a variable to return\nthe header value in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_iter_next" soup_message_headers_iter_next :: 
    Ptr MessageHeadersIter ->               -- iter : TInterface (Name {namespace = "Soup", name = "MessageHeadersIter"})
    Ptr CString ->                          -- name : TBasicType TUTF8
    Ptr CString ->                          -- value : TBasicType TUTF8
    IO CInt

-- | Yields the next name\/value pair in the @/SoupMessageHeaders/@ being
-- iterated by /@iter@/. If /@iter@/ has already yielded the last header,
-- then 'GI.Soup.Structs.MessageHeadersIter.messageHeadersIterNext' will return 'P.False' and /@name@/
-- and /@value@/ will be unchanged.
messageHeadersIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeadersIter
    -- ^ /@iter@/: a @/SoupMessageHeadersIter/@
    -> m ((Bool, T.Text, T.Text))
    -- ^ __Returns:__ 'P.True' if another name and value were returned, 'P.False'
    -- if the end of the headers has been reached.
messageHeadersIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeadersIter -> m (Bool, Text, Text)
messageHeadersIterNext 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-2.4.26/docs/GI-Soup-Structs-MessageHeadersIter.html#v:messageHeadersIterNext"
        })


#endif

-- method MessageHeadersIter::init
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MessageHeadersIter" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to a %SoupMessageHeadersIter\nstructure"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a %SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_iter_init" soup_message_headers_iter_init :: 
    Ptr MessageHeadersIter ->               -- iter : TInterface (Name {namespace = "Soup", name = "MessageHeadersIter"})
    Ptr Soup.MessageHeaders.MessageHeaders -> -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

-- | Initializes /@iter@/ for iterating /@hdrs@/.
messageHeadersIterInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Soup.MessageHeaders.MessageHeaders
    -- ^ /@hdrs@/: a @/SoupMessageHeaders/@
    -> m (MessageHeadersIter)
messageHeadersIterInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m MessageHeadersIter
messageHeadersIterInit 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 :: *) :: * 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