    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- An opaque structure representing a HMAC operation.
    -- To create a new GHmac, use @/g_hmac_new()/@. To free
    -- a GHmac, use 'GI.GLib.Structs.Hmac.hmacUnref'.
    --
    -- /Since: 2.30/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.GLib.Structs.Hmac
        (

    -- * Exported types
        Hmac(..)                                ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveHmacMethod                       ,
    #endif

    -- ** getDigest #method:getDigest#

    #if defined(ENABLE_OVERLOADING)
        HmacGetDigestMethodInfo                 ,
    #endif
        hmacGetDigest                           ,

    -- ** getString #method:getString#

    #if defined(ENABLE_OVERLOADING)
        HmacGetStringMethodInfo                 ,
    #endif
        hmacGetString                           ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        HmacUnrefMethodInfo                     ,
    #endif
        hmacUnref                               ,

    -- ** update #method:update#

    #if defined(ENABLE_OVERLOADING)
        HmacUpdateMethodInfo                    ,
    #endif
        hmacUpdate                              ,

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

    -- | Memory-managed wrapper type.
    newtype Hmac = Hmac (SP.ManagedPtr Hmac)
        deriving (Hmac -> Hmac -> Bool
    (Hmac -> Hmac -> Bool) -> (Hmac -> Hmac -> Bool) -> Eq Hmac
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Hmac -> Hmac -> Bool
    $c/= :: Hmac -> Hmac -> Bool
    == :: Hmac -> Hmac -> Bool
    $c== :: Hmac -> Hmac -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Hmac where
        toManagedPtr :: Hmac -> ManagedPtr Hmac
    toManagedPtr (Hmac p :: ManagedPtr Hmac
    p) = ManagedPtr Hmac
    p

    -- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
    instance BoxedPtr Hmac where
        boxedPtrCopy :: Hmac -> IO Hmac
    boxedPtrCopy = Hmac -> IO Hmac
    forall (m :: * -> *) a. Monad m => a -> m a
    return
        boxedPtrFree :: Hmac -> IO ()
    boxedPtrFree = \_x :: Hmac
    _x -> () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    -- method Hmac::get_digest
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "hmac"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Hmac" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GHmac" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "buffer"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "output buffer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "digest_len"
    --           , argType = TBasicType TUInt64
    --           , direction = DirectionInout
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "an inout parameter. The caller initializes it to the\n  size of @buffer. After the call it contains the length of the digest"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "digest_len"
    --              , argType = TBasicType TUInt64
    --              , direction = DirectionInout
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just
    --                          "an inout parameter. The caller initializes it to the\n  size of @buffer. After the call it contains the length of the digest"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , transfer = TransferEverything
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_hmac_get_digest" g_hmac_get_digest ::
        Ptr Hmac ->                             -- hmac : TInterface (Name {namespace = "GLib", name = "Hmac"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Ptr Word64 ->                           -- digest_len : TBasicType TUInt64
        IO ()

    -- | Gets the digest from /@checksum@/ as a raw binary array and places it
    -- into /@buffer@/. The size of the digest depends on the type of checksum.
    --
    -- Once this function has been called, the t'GI.GLib.Structs.Hmac.Hmac' is closed and can
    -- no longer be updated with 'GI.GLib.Structs.Checksum.checksumUpdate'.
    --
    -- /Since: 2.30/
    hmacGetDigest ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Hmac
        -- ^ /@hmac@/: a t'GI.GLib.Structs.Hmac.Hmac'
        -> ByteString
        -- ^ /@buffer@/: output buffer
        -> m ()
    hmacGetDigest :: Hmac -> ByteString -> m ()
    hmacGetDigest hmac :: Hmac
    hmac buffer :: ByteString
    buffer = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let digestLen :: Word64
    digestLen = Int -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word64) -> Int -> Word64
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    buffer
        Ptr Hmac
    hmac' <- Hmac -> IO (Ptr Hmac)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Hmac
    hmac
        Ptr Word8
    buffer' <- ByteString -> IO (Ptr Word8)
    packByteString ByteString
    buffer
        Ptr Word64
    digestLen' <- IO (Ptr Word64)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Word64)
        Ptr Word64 -> Word64 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr Word64
    digestLen' Word64
    digestLen
        Ptr Hmac -> Ptr Word8 -> Ptr Word64 -> IO ()
    g_hmac_get_digest Ptr Hmac
    hmac' Ptr Word8
    buffer' Ptr Word64
    digestLen'
        Word64
    digestLen'' <- Ptr Word64 -> IO Word64
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word64
    digestLen'
        Hmac -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Hmac
    hmac
        Ptr Word8 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Word8
    buffer'
        Ptr Word64 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Word64
    digestLen'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data HmacGetDigestMethodInfo
    instance (signature ~ (ByteString -> m ()), MonadIO m) => O.MethodInfo HmacGetDigestMethodInfo Hmac signature where
        overloadedMethod = hmacGetDigest

    #endif

    -- method Hmac::get_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "hmac"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Hmac" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GHmac" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_hmac_get_string" g_hmac_get_string ::
        Ptr Hmac ->                             -- hmac : TInterface (Name {namespace = "GLib", name = "Hmac"})
        IO CString

    -- | Gets the HMAC as a hexadecimal string.
    --
    -- Once this function has been called the t'GI.GLib.Structs.Hmac.Hmac' can no longer be
    -- updated with 'GI.GLib.Structs.Hmac.hmacUpdate'.
    --
    -- The hexadecimal characters will be lower case.
    --
    -- /Since: 2.30/
    hmacGetString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Hmac
        -- ^ /@hmac@/: a t'GI.GLib.Structs.Hmac.Hmac'
        -> m T.Text
        -- ^ __Returns:__ the hexadecimal representation of the HMAC. The
        --   returned string is owned by the HMAC and should not be modified
        --   or freed.
    hmacGetString :: Hmac -> m Text
    hmacGetString hmac :: Hmac
    hmac = IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Hmac
    hmac' <- Hmac -> IO (Ptr Hmac)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Hmac
    hmac
        CString
    result <- Ptr Hmac -> IO CString
    g_hmac_get_string Ptr Hmac
    hmac'
        Text -> CString -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "hmacGetString" CString
    result
        Text
    result' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    result
        Hmac -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Hmac
    hmac
        Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    result'

    #if defined(ENABLE_OVERLOADING)
    data HmacGetStringMethodInfo
    instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo HmacGetStringMethodInfo Hmac signature where
        overloadedMethod = hmacGetString

    #endif

    -- method Hmac::unref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "hmac"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Hmac" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GHmac" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_hmac_unref" g_hmac_unref ::
        Ptr Hmac ->                             -- hmac : TInterface (Name {namespace = "GLib", name = "Hmac"})
        IO ()

    -- | Atomically decrements the reference count of /@hmac@/ by one.
    --
    -- If the reference count drops to 0, all keys and values will be
    -- destroyed, and all memory allocated by the hash table is released.
    -- This function is MT-safe and may be called from any thread.
    -- Frees the memory allocated for /@hmac@/.
    --
    -- /Since: 2.30/
    hmacUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Hmac
        -- ^ /@hmac@/: a t'GI.GLib.Structs.Hmac.Hmac'
        -> m ()
    hmacUnref :: Hmac -> m ()
    hmacUnref hmac :: Hmac
    hmac = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Hmac
    hmac' <- Hmac -> IO (Ptr Hmac)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Hmac
    hmac
        Ptr Hmac -> IO ()
    g_hmac_unref Ptr Hmac
    hmac'
        Hmac -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Hmac
    hmac
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data HmacUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo HmacUnrefMethodInfo Hmac signature where
        overloadedMethod = hmacUnref

    #endif

    -- method Hmac::update
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "hmac"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Hmac" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GHmac" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "data"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "buffer used to compute the checksum"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "length"
    --           , argType = TBasicType TInt64
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "size of the buffer, or -1 if it is a nul-terminated string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "length"
    --              , argType = TBasicType TInt64
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just "size of the buffer, or -1 if it is a nul-terminated string"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_hmac_update" g_hmac_update ::
        Ptr Hmac ->                             -- hmac : TInterface (Name {namespace = "GLib", name = "Hmac"})
        Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
        Int64 ->                                -- length : TBasicType TInt64
        IO ()

    -- | Feeds /@data@/ into an existing t'GI.GLib.Structs.Hmac.Hmac'.
    --
    -- The HMAC must still be open, that is 'GI.GLib.Structs.Hmac.hmacGetString' or
    -- 'GI.GLib.Structs.Hmac.hmacGetDigest' must not have been called on /@hmac@/.
    --
    -- /Since: 2.30/
    hmacUpdate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Hmac
        -- ^ /@hmac@/: a t'GI.GLib.Structs.Hmac.Hmac'
        -> ByteString
        -- ^ /@data@/: buffer used to compute the checksum
        -> m ()
    hmacUpdate :: Hmac -> ByteString -> m ()
    hmacUpdate hmac :: Hmac
    hmac data_ :: ByteString
    data_ = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        let length_ :: Int64
    length_ = Int -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int64) -> Int -> Int64
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    data_
        Ptr Hmac
    hmac' <- Hmac -> IO (Ptr Hmac)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Hmac
    hmac
        Ptr Word8
    data_' <- ByteString -> IO (Ptr Word8)
    packByteString ByteString
    data_
        Ptr Hmac -> Ptr Word8 -> Int64 -> IO ()
    g_hmac_update Ptr Hmac
    hmac' Ptr Word8
    data_' Int64
    length_
        Hmac -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Hmac
    hmac
        Ptr Word8 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Word8
    data_'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data HmacUpdateMethodInfo
    instance (signature ~ (ByteString -> m ()), MonadIO m) => O.MethodInfo HmacUpdateMethodInfo Hmac signature where
        overloadedMethod = hmacUpdate

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveHmacMethod (t :: Symbol) (o :: *) :: * where
        ResolveHmacMethod "unref" o = HmacUnrefMethodInfo
        ResolveHmacMethod "update" o = HmacUpdateMethodInfo
        ResolveHmacMethod "getDigest" o = HmacGetDigestMethodInfo
        ResolveHmacMethod "getString" o = HmacGetStringMethodInfo
        ResolveHmacMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveHmacMethod t Hmac, O.MethodInfo info Hmac p) => OL.IsLabel t (Hmac -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #endif