QRandomGenerator.hs

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

module Graphics.UI.Qtah.Generated.Core.QRandomGenerator (
  QRandomGeneratorValue (..),
  QRandomGeneratorConstPtr (..),
  eQ,
  nE,
  QRandomGeneratorPtr (..),
  boundedWithDouble,
  boundedWithQuint,
  boundedWirhQuints,
  boundedWithInt,
  boundedWithInts,
  discard,
  fillRange,
  generate64,
  generate,
  generateDouble,
  seed,
  seedWithQuint,
  cALL,
  aSSIGN,
  global,
  max,
  min,
  securelySeeded,
  system,
  QRandomGeneratorConst (..),
  castQRandomGeneratorToConst,
  QRandomGenerator (..),
  castQRandomGeneratorToNonconst,
  newWithQuints,
  newWithQuintQsizetype,
  new,
  newWithQuint,
  newCopy,
  QRandomGeneratorSuper (..),
  QRandomGeneratorSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Data.Word as HoppyDW
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified System.Posix.Types as HoppySPT

foreign import ccall "genpop__QRandomGenerator_newWithQuints" newWithQuints' ::  HoppyF.Ptr HoppyDW.Word32 -> HoppyF.Ptr HoppyDW.Word32 -> HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_newWithQuintQsizetype" newWithQuintQsizetype' ::  HoppyF.Ptr HoppyDW.Word32 -> HoppySPT.CSsize -> HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_new" new' ::  HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_newWithQuint" newWithQuint' ::  HoppyDW.Word32 -> HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_newCopy" newCopy' ::  HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_boundedWithDouble" boundedWithDouble' ::  HoppyF.Ptr QRandomGenerator -> HoppyFC.CDouble -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QRandomGenerator_boundedWithQuint" boundedWithQuint' ::  HoppyF.Ptr QRandomGenerator -> HoppyDW.Word32 -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_boundedWirhQuints" boundedWirhQuints' ::  HoppyF.Ptr QRandomGenerator -> HoppyDW.Word32 -> HoppyDW.Word32 -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_boundedWithInt" boundedWithInt' ::  HoppyF.Ptr QRandomGenerator -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QRandomGenerator_boundedWithInts" boundedWithInts' ::  HoppyF.Ptr QRandomGenerator -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QRandomGenerator_discard" discard' ::  HoppyF.Ptr QRandomGenerator -> HoppyFC.CULLong -> HoppyP.IO ()
foreign import ccall "genpop__QRandomGenerator_fillRange" fillRange' ::  HoppyF.Ptr QRandomGenerator -> HoppyF.Ptr HoppyFC.CUInt -> HoppySPT.CSsize -> HoppyP.IO ()
foreign import ccall "genpop__QRandomGenerator_generate64" generate64' ::  HoppyF.Ptr QRandomGenerator -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QRandomGenerator_generate" generate' ::  HoppyF.Ptr QRandomGenerator -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_generateDouble" generateDouble' ::  HoppyF.Ptr QRandomGenerator -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QRandomGenerator_global" global' ::  HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_max" max' ::  HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_min" min' ::  HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_securelySeeded" securelySeeded' ::  HoppyP.IO (HoppyF.Ptr QRandomGeneratorConst)
foreign import ccall "genpop__QRandomGenerator_seed" seed' ::  HoppyF.Ptr QRandomGenerator -> HoppyP.IO ()
foreign import ccall "genpop__QRandomGenerator_seedWithQuint" seedWithQuint' ::  HoppyF.Ptr QRandomGenerator -> HoppyDW.Word32 -> HoppyP.IO ()
foreign import ccall "genpop__QRandomGenerator_system" system' ::  HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "genpop__QRandomGenerator_CALL" cALL' ::  HoppyF.Ptr QRandomGenerator -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QRandomGenerator_EQ" eQ' ::  HoppyF.Ptr QRandomGeneratorConst -> HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QRandomGenerator_NE" nE' ::  HoppyF.Ptr QRandomGeneratorConst -> HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QRandomGenerator_ASSIGN" aSSIGN' ::  HoppyF.Ptr QRandomGenerator -> HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO (HoppyF.Ptr QRandomGenerator)
foreign import ccall "gendel__QRandomGenerator" delete'QRandomGenerator :: HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO ()
foreign import ccall "&gendel__QRandomGenerator" deletePtr'QRandomGenerator :: HoppyF.FunPtr (HoppyF.Ptr QRandomGeneratorConst -> HoppyP.IO ())

class QRandomGeneratorValue a where
  withQRandomGeneratorPtr :: a -> (QRandomGeneratorConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QRandomGeneratorConstPtr a => QRandomGeneratorValue a where
  withQRandomGeneratorPtr = HoppyP.flip ($) . toQRandomGeneratorConst

class (HoppyFHR.CppPtr this) => QRandomGeneratorConstPtr this where
  toQRandomGeneratorConst :: this -> QRandomGeneratorConst

eQ :: (QRandomGeneratorValue this, QRandomGeneratorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQRandomGeneratorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQRandomGeneratorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QRandomGeneratorValue this, QRandomGeneratorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQRandomGeneratorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQRandomGeneratorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QRandomGeneratorConstPtr this) => QRandomGeneratorPtr this where
  toQRandomGenerator :: this -> QRandomGenerator

boundedWithDouble :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO HoppyP.Double)
boundedWithDouble arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (boundedWithDouble' arg'1' arg'2')

boundedWithQuint :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyDW.Word32) -> (HoppyP.IO HoppyDW.Word32)
boundedWithQuint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (boundedWithQuint' arg'1' arg'2')

boundedWirhQuints :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyDW.Word32) -> (HoppyDW.Word32) -> (HoppyP.IO HoppyDW.Word32)
boundedWirhQuints arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (boundedWirhQuints' arg'1' arg'2' arg'3')

boundedWithInt :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
boundedWithInt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (boundedWithInt' arg'1' arg'2')

boundedWithInts :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
boundedWithInts arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (boundedWithInts' arg'1' arg'2' arg'3')

discard :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyFC.CULLong) -> (HoppyP.IO ())
discard arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (discard' arg'1' arg'2')

fillRange :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CUInt) -> (HoppySPT.CSsize) -> (HoppyP.IO ())
fillRange arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (fillRange' arg'1' arg'2' arg'3')

generate64 :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word64)
generate64 arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (generate64' arg'1')

generate :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
generate arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (generate' arg'1')

generateDouble :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
generateDouble arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (generateDouble' arg'1')

seed :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
seed arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (seed' arg'1')

seedWithQuint :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyDW.Word32) -> (HoppyP.IO ())
seedWithQuint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (seedWithQuint' arg'1' arg'2')

cALL :: (QRandomGeneratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
cALL arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  (cALL' arg'1')

aSSIGN :: (QRandomGeneratorPtr this, QRandomGeneratorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QRandomGenerator)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator arg'1) $ \arg'1' ->
  withQRandomGeneratorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QRandomGenerator
  (aSSIGN' arg'1' arg'2')

global :: (HoppyP.IO QRandomGenerator)
global =
  HoppyP.fmap QRandomGenerator
  (global')

max :: (HoppyP.IO HoppyDW.Word32)
max =
  (max')

min :: (HoppyP.IO HoppyDW.Word32)
min =
  (min')

securelySeeded :: (HoppyP.IO QRandomGenerator)
securelySeeded =
  (HoppyFHR.decodeAndDelete . QRandomGeneratorConst) =<<
  (securelySeeded')

system :: (HoppyP.IO QRandomGenerator)
system =
  HoppyP.fmap QRandomGenerator
  (system')

data QRandomGeneratorConst =
    QRandomGeneratorConst (HoppyF.Ptr QRandomGeneratorConst)
  | QRandomGeneratorConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QRandomGeneratorConst)
  deriving (HoppyP.Show)

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

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

castQRandomGeneratorToConst :: QRandomGenerator -> QRandomGeneratorConst
castQRandomGeneratorToConst (QRandomGenerator ptr') = QRandomGeneratorConst $ HoppyF.castPtr ptr'
castQRandomGeneratorToConst (QRandomGeneratorGc fptr' ptr') = QRandomGeneratorConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QRandomGeneratorConst QRandomGenerator where copy = newCopy

instance QRandomGeneratorConstPtr QRandomGeneratorConst where
  toQRandomGeneratorConst = HoppyP.id

data QRandomGenerator =
    QRandomGenerator (HoppyF.Ptr QRandomGenerator)
  | QRandomGeneratorGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QRandomGenerator)
  deriving (HoppyP.Show)

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

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

castQRandomGeneratorToNonconst :: QRandomGeneratorConst -> QRandomGenerator
castQRandomGeneratorToNonconst (QRandomGeneratorConst ptr') = QRandomGenerator $ HoppyF.castPtr ptr'
castQRandomGeneratorToNonconst (QRandomGeneratorConstGc fptr' ptr') = QRandomGeneratorGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QRandomGenerator QRandomGenerator where copy = newCopy

instance QRandomGeneratorConstPtr QRandomGenerator where
  toQRandomGeneratorConst (QRandomGenerator ptr') = QRandomGeneratorConst $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator -> HoppyF.Ptr QRandomGeneratorConst) ptr'
  toQRandomGeneratorConst (QRandomGeneratorGc fptr' ptr') = QRandomGeneratorConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator -> HoppyF.Ptr QRandomGeneratorConst) ptr'

instance QRandomGeneratorPtr QRandomGenerator where
  toQRandomGenerator = HoppyP.id

newWithQuints :: (HoppyF.Ptr HoppyDW.Word32) -> (HoppyF.Ptr HoppyDW.Word32) -> (HoppyP.IO QRandomGenerator)
newWithQuints arg'1 arg'2 =
  let arg'1' = arg'1 in
  let arg'2' = arg'2 in
  HoppyP.fmap QRandomGenerator
  (newWithQuints' arg'1' arg'2')

newWithQuintQsizetype :: (HoppyF.Ptr HoppyDW.Word32) -> (HoppySPT.CSsize) -> (HoppyP.IO QRandomGenerator)
newWithQuintQsizetype arg'1 arg'2 =
  let arg'1' = arg'1 in
  let arg'2' = arg'2 in
  HoppyP.fmap QRandomGenerator
  (newWithQuintQsizetype' arg'1' arg'2')

new :: (HoppyP.IO QRandomGenerator)
new =
  HoppyP.fmap QRandomGenerator
  (new')

newWithQuint :: (HoppyDW.Word32) -> (HoppyP.IO QRandomGenerator)
newWithQuint arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QRandomGenerator
  (newWithQuint' arg'1')

newCopy :: (QRandomGeneratorValue arg'1) => (arg'1) -> (HoppyP.IO QRandomGenerator)
newCopy arg'1 =
  withQRandomGeneratorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QRandomGenerator
  (newCopy' arg'1')

class QRandomGeneratorSuper a where
  downToQRandomGenerator :: a -> QRandomGenerator


class QRandomGeneratorSuperConst a where
  downToQRandomGeneratorConst :: a -> QRandomGeneratorConst


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

instance QRandomGeneratorValue a => HoppyFHR.Assignable QRandomGenerator a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QRandomGenerator (QRandomGenerator) where
  decode = HoppyFHR.decode . toQRandomGeneratorConst

instance HoppyFHR.Decodable QRandomGeneratorConst (QRandomGenerator) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc