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

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

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

module GI.Soup.Structs.MessageHeadersIter
    ( 

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


 -- * Methods
-- ** init #method:init#

    messageHeadersIterInit                  ,


-- ** next #method:next#

#if 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.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 {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders

-- | Memory-managed wrapper type.
newtype MessageHeadersIter = MessageHeadersIter (ManagedPtr MessageHeadersIter)
instance WrappedPtr MessageHeadersIter where
    wrappedPtrCalloc = callocBytes 24
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr MessageHeadersIter)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `MessageHeadersIter` struct initialized to zero.
newZeroMessageHeadersIter :: MonadIO m => m MessageHeadersIter
newZeroMessageHeadersIter = liftIO $ wrappedPtrCalloc >>= wrapPtr MessageHeadersIter

instance tag ~ 'AttrSet => Constructible MessageHeadersIter tag where
    new _ attrs = do
        o <- newZeroMessageHeadersIter
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `MessageHeadersIter`.
noMessageHeadersIter :: Maybe MessageHeadersIter
noMessageHeadersIter = Nothing


#if 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 '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:__ 'True' if another name and value were returned, 'False'
if the end of the headers has been reached. -}
messageHeadersIterNext iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    name <- allocMem :: IO (Ptr CString)
    value <- allocMem :: IO (Ptr CString)
    result <- soup_message_headers_iter_next iter' name value
    let result' = (/= 0) result
    name' <- peek name
    name'' <- cstringToText name'
    value' <- peek value
    value'' <- cstringToText value'
    touchManagedPtr iter
    freeMem name
    freeMem value
    return (result', name'', value'')

#if ENABLE_OVERLOADING
data MessageHeadersIterNextMethodInfo
instance (signature ~ (m ((Bool, T.Text, T.Text))), MonadIO m) => O.MethodInfo MessageHeadersIterNextMethodInfo MessageHeadersIter signature where
    overloadedMethod _ = 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 hdrs = liftIO $ do
    iter <- callocBytes 24 :: IO (Ptr MessageHeadersIter)
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_iter_init iter hdrs'
    iter' <- (wrapPtr MessageHeadersIter) iter
    touchManagedPtr hdrs
    return iter'

#if ENABLE_OVERLOADING
#endif

#if 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.MethodInfo info MessageHeadersIter p) => OL.IsLabel t (MessageHeadersIter -> 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