{-# 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 (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GLib.Structs.Hmac
    ( 

-- * Exported types
    Hmac(..)                                ,
    noHmac                                  ,


 -- * 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.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.GI.Base.Signals as B.Signals
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 (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)
-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance WrappedPtr Hmac where
    wrappedPtrCalloc :: IO (Ptr Hmac)
wrappedPtrCalloc = Ptr Hmac -> IO (Ptr Hmac)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Hmac
forall a. Ptr a
nullPtr
    wrappedPtrCopy :: Hmac -> IO Hmac
wrappedPtrCopy = Hmac -> IO Hmac
forall (m :: * -> *) a. Monad m => a -> m a
return
    wrappedPtrFree :: Maybe (GDestroyNotify Hmac)
wrappedPtrFree = Maybe (GDestroyNotify Hmac)
forall a. Maybe a
Nothing

-- | A convenience alias for `Nothing` :: `Maybe` `Hmac`.
noHmac :: Maybe Hmac
noHmac :: Maybe Hmac
noHmac = Maybe Hmac
forall a. Maybe a
Nothing


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