QCryptographicHash.hs

{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Core.QCryptographicHash (
  QCryptographicHashValue (..),
  QCryptographicHashConstPtr (..),
  result,
  QCryptographicHashPtr (..),
  addDataRaw,
  addDataByteArray,
  addDataIODevice,
  reset,
  hash,
  hashLength,
  QCryptographicHashConst (..),
  castQCryptographicHashToConst,
  QCryptographicHash (..),
  castQCryptographicHashToNonconst,
  new,
  QCryptographicHashSuper (..),
  QCryptographicHashSuperConst (..),
  QCryptographicHashAlgorithm (..),
  ) where

import qualified Data.ByteString as QtahDBS
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QIODevice as M48
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QCryptographicHash_new" new' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QCryptographicHash)
foreign import ccall "genpop__QCryptographicHash_addDataRaw" addDataRaw' ::  HoppyF.Ptr QCryptographicHash -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QCryptographicHash_addDataByteArray" addDataByteArray' ::  HoppyF.Ptr QCryptographicHash -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QCryptographicHash_addDataIODevice" addDataIODevice' ::  HoppyF.Ptr QCryptographicHash -> HoppyF.Ptr M48.QIODevice -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QCryptographicHash_hash" hash' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QCryptographicHash_hashLength" hashLength' ::  HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QCryptographicHash_reset" reset' ::  HoppyF.Ptr QCryptographicHash -> HoppyP.IO ()
foreign import ccall "genpop__QCryptographicHash_result" result' ::  HoppyF.Ptr QCryptographicHashConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "gendel__QCryptographicHash" delete'QCryptographicHash :: HoppyF.Ptr QCryptographicHashConst -> HoppyP.IO ()
foreign import ccall "&gendel__QCryptographicHash" deletePtr'QCryptographicHash :: HoppyF.FunPtr (HoppyF.Ptr QCryptographicHashConst -> HoppyP.IO ())

class QCryptographicHashValue a where
  withQCryptographicHashPtr :: a -> (QCryptographicHashConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QCryptographicHashConstPtr a => QCryptographicHashValue a where
  withQCryptographicHashPtr = HoppyP.flip ($) . toQCryptographicHashConst

class (HoppyFHR.CppPtr this) => QCryptographicHashConstPtr this where
  toQCryptographicHashConst :: this -> QCryptographicHashConst

result :: (QCryptographicHashValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
result arg'1 =
  withQCryptographicHashPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (result' arg'1')

class (QCryptographicHashConstPtr this) => QCryptographicHashPtr this where
  toQCryptographicHash :: this -> QCryptographicHash

addDataRaw :: (QCryptographicHashPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO ())
addDataRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQCryptographicHash arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (addDataRaw' arg'1' arg'2' arg'3')

addDataByteArray :: (QCryptographicHashPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addDataByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQCryptographicHash arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (addDataByteArray' arg'1' arg'2')

addDataIODevice :: (QCryptographicHashPtr this, M48.QIODevicePtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
addDataIODevice arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQCryptographicHash arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M48.toQIODevice arg'2) $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (addDataIODevice' arg'1' arg'2')

reset :: (QCryptographicHashPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
reset arg'1 =
  HoppyFHR.withCppPtr (toQCryptographicHash arg'1) $ \arg'1' ->
  (reset' arg'1')

hash :: (M12.QByteArrayValue arg'1) => (arg'1) -> (QCryptographicHashAlgorithm) -> (HoppyP.IO QtahDBS.ByteString)
hash arg'1 arg'2 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (hash' arg'1' arg'2')

hashLength :: (QCryptographicHashAlgorithm) -> (HoppyP.IO HoppyP.Int)
hashLength arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (hashLength' arg'1')

data QCryptographicHashConst =
    QCryptographicHashConst (HoppyF.Ptr QCryptographicHashConst)
  | QCryptographicHashConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QCryptographicHashConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QCryptographicHashConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QCryptographicHashConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQCryptographicHashToConst :: QCryptographicHash -> QCryptographicHashConst
castQCryptographicHashToConst (QCryptographicHash ptr') = QCryptographicHashConst $ HoppyF.castPtr ptr'
castQCryptographicHashToConst (QCryptographicHashGc fptr' ptr') = QCryptographicHashConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QCryptographicHashConst where
  nullptr = QCryptographicHashConst HoppyF.nullPtr
  
  withCppPtr (QCryptographicHashConst ptr') f' = f' ptr'
  withCppPtr (QCryptographicHashConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QCryptographicHashConst ptr') = ptr'
  toPtr (QCryptographicHashConstGc _ ptr') = ptr'
  
  touchCppPtr (QCryptographicHashConst _) = HoppyP.return ()
  touchCppPtr (QCryptographicHashConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QCryptographicHashConst where
  delete (QCryptographicHashConst ptr') = delete'QCryptographicHash ptr'
  delete (QCryptographicHashConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QCryptographicHashConst", " object."]
  
  toGc this'@(QCryptographicHashConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QCryptographicHashConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QCryptographicHash :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QCryptographicHashConstGc {}) = HoppyP.return this'

instance QCryptographicHashConstPtr QCryptographicHashConst where
  toQCryptographicHashConst = HoppyP.id

data QCryptographicHash =
    QCryptographicHash (HoppyF.Ptr QCryptographicHash)
  | QCryptographicHashGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QCryptographicHash)
  deriving (HoppyP.Show)

instance HoppyP.Eq QCryptographicHash where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QCryptographicHash where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQCryptographicHashToNonconst :: QCryptographicHashConst -> QCryptographicHash
castQCryptographicHashToNonconst (QCryptographicHashConst ptr') = QCryptographicHash $ HoppyF.castPtr ptr'
castQCryptographicHashToNonconst (QCryptographicHashConstGc fptr' ptr') = QCryptographicHashGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QCryptographicHash where
  nullptr = QCryptographicHash HoppyF.nullPtr
  
  withCppPtr (QCryptographicHash ptr') f' = f' ptr'
  withCppPtr (QCryptographicHashGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QCryptographicHash ptr') = ptr'
  toPtr (QCryptographicHashGc _ ptr') = ptr'
  
  touchCppPtr (QCryptographicHash _) = HoppyP.return ()
  touchCppPtr (QCryptographicHashGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QCryptographicHash where
  delete (QCryptographicHash ptr') = delete'QCryptographicHash $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QCryptographicHashConst)
  delete (QCryptographicHashGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QCryptographicHash", " object."]
  
  toGc this'@(QCryptographicHash ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QCryptographicHashGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QCryptographicHash :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QCryptographicHashGc {}) = HoppyP.return this'

instance QCryptographicHashConstPtr QCryptographicHash where
  toQCryptographicHashConst (QCryptographicHash ptr') = QCryptographicHashConst $ (HoppyF.castPtr :: HoppyF.Ptr QCryptographicHash -> HoppyF.Ptr QCryptographicHashConst) ptr'
  toQCryptographicHashConst (QCryptographicHashGc fptr' ptr') = QCryptographicHashConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QCryptographicHash -> HoppyF.Ptr QCryptographicHashConst) ptr'

instance QCryptographicHashPtr QCryptographicHash where
  toQCryptographicHash = HoppyP.id

new :: (QCryptographicHashAlgorithm) -> (HoppyP.IO QCryptographicHash)
new arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QCryptographicHash
  (new' arg'1')

class QCryptographicHashSuper a where
  downToQCryptographicHash :: a -> QCryptographicHash


class QCryptographicHashSuperConst a where
  downToQCryptographicHashConst :: a -> QCryptographicHashConst


instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QCryptographicHash)) QCryptographicHash where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QCryptographicHash)) QCryptographicHash where
  decode = HoppyP.fmap QCryptographicHash . HoppyF.peek

data QCryptographicHashAlgorithm =
  Md4
  | Md5
  | Sha1
  | Sha224
  | Sha256
  | Sha384
  | Sha512
  | Sha3224
  | Sha3256
  | Sha3384
  | Sha3512
  | Keccak224
  | Keccak256
  | Keccak384
  | Keccak512
  | UnknownQCryptographicHashAlgorithm (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCryptographicHashAlgorithm where
  fromCppEnum Md4 = 0
  fromCppEnum Md5 = 1
  fromCppEnum Sha1 = 2
  fromCppEnum Sha224 = 3
  fromCppEnum Sha256 = 4
  fromCppEnum Sha384 = 5
  fromCppEnum Sha512 = 6
  fromCppEnum Sha3224 = 11
  fromCppEnum Sha3256 = 12
  fromCppEnum Sha3384 = 13
  fromCppEnum Sha3512 = 14
  fromCppEnum Keccak224 = 7
  fromCppEnum Keccak256 = 8
  fromCppEnum Keccak384 = 9
  fromCppEnum Keccak512 = 10
  fromCppEnum (UnknownQCryptographicHashAlgorithm n) = n
  
  toCppEnum (0) = Md4
  toCppEnum (1) = Md5
  toCppEnum (2) = Sha1
  toCppEnum (3) = Sha224
  toCppEnum (4) = Sha256
  toCppEnum (5) = Sha384
  toCppEnum (6) = Sha512
  toCppEnum (7) = Keccak224
  toCppEnum (8) = Keccak256
  toCppEnum (9) = Keccak384
  toCppEnum (10) = Keccak512
  toCppEnum (11) = Sha3224
  toCppEnum (12) = Sha3256
  toCppEnum (13) = Sha3384
  toCppEnum (14) = Sha3512
  toCppEnum n = UnknownQCryptographicHashAlgorithm n

instance HoppyP.Eq QCryptographicHashAlgorithm where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QCryptographicHashAlgorithm where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)