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

module Graphics.UI.Qtah.Generated.Core.QRandomGenerator64 (
  castQRandomGenerator64ToQRandomGenerator,
  QRandomGenerator64Value (..),
  QRandomGenerator64ConstPtr (..),
  eQ,
  nE,
  QRandomGenerator64Ptr (..),
  generate,
  cALL,
  aSSIGN,
  max,
  min,
  QRandomGenerator64Const (..),
  castQRandomGenerator64ToConst,
  QRandomGenerator64 (..),
  castQRandomGenerator64ToNonconst,
  newWithQuints,
  newWithQuintQsizetype,
  new,
  newWithQuint,
  newCopy,
  QRandomGenerator64Super (..),
  QRandomGenerator64SuperConst (..),
  ) 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 qualified Graphics.UI.Qtah.Generated.Core.QRandomGenerator as M118
import Prelude (($), (.), (/=), (=<<), (==), (>>))
import qualified Prelude as HoppyP
import qualified System.Posix.Types as HoppySPT

foreign import ccall "genpop__QRandomGenerator64_newWithQuints" newWithQuints' ::  HoppyF.Ptr HoppyDW.Word32 -> HoppyF.Ptr HoppyDW.Word32 -> HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "genpop__QRandomGenerator64_newWithQuintQsizetype" newWithQuintQsizetype' ::  HoppyF.Ptr HoppyDW.Word32 -> HoppySPT.CSsize -> HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "genpop__QRandomGenerator64_new" new' ::  HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "genpop__QRandomGenerator64_newWithQuint" newWithQuint' ::  HoppyDW.Word32 -> HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "genpop__QRandomGenerator64_newCopy" newCopy' ::  HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "genpop__QRandomGenerator64_generate" generate' ::  HoppyF.Ptr QRandomGenerator64 -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QRandomGenerator64_max" max' ::  HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QRandomGenerator64_min" min' ::  HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QRandomGenerator64_CALL" cALL' ::  HoppyF.Ptr QRandomGenerator64 -> HoppyP.IO HoppyDW.Word64
foreign import ccall "genpop__QRandomGenerator64_EQ" eQ' ::  HoppyF.Ptr QRandomGenerator64Const -> HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QRandomGenerator64_NE" nE' ::  HoppyF.Ptr QRandomGenerator64Const -> HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QRandomGenerator64_ASSIGN" aSSIGN' ::  HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO (HoppyF.Ptr QRandomGenerator64)
foreign import ccall "gencast__QRandomGenerator64__QRandomGenerator" castQRandomGenerator64ToQRandomGenerator :: HoppyF.Ptr QRandomGenerator64Const -> HoppyF.Ptr M118.QRandomGeneratorConst
foreign import ccall "gendel__QRandomGenerator64" delete'QRandomGenerator64 :: HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO ()
foreign import ccall "&gendel__QRandomGenerator64" deletePtr'QRandomGenerator64 :: HoppyF.FunPtr (HoppyF.Ptr QRandomGenerator64Const -> HoppyP.IO ())

class QRandomGenerator64Value a where
  withQRandomGenerator64Ptr :: a -> (QRandomGenerator64Const -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QRandomGenerator64ConstPtr a => QRandomGenerator64Value a where
  withQRandomGenerator64Ptr = HoppyP.flip ($) . toQRandomGenerator64Const

class (M118.QRandomGeneratorConstPtr this) => QRandomGenerator64ConstPtr this where
  toQRandomGenerator64Const :: this -> QRandomGenerator64Const

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

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

class (QRandomGenerator64ConstPtr this, M118.QRandomGeneratorPtr this) => QRandomGenerator64Ptr this where
  toQRandomGenerator64 :: this -> QRandomGenerator64

generate :: (QRandomGenerator64Ptr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word64)
generate arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator64 arg'1) $ \arg'1' ->
  (generate' arg'1')

cALL :: (QRandomGenerator64Ptr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word64)
cALL arg'1 =
  HoppyFHR.withCppPtr (toQRandomGenerator64 arg'1) $ \arg'1' ->
  (cALL' arg'1')

aSSIGN :: (QRandomGenerator64Ptr this, QRandomGenerator64Value arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QRandomGenerator64)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQRandomGenerator64 arg'1) $ \arg'1' ->
  withQRandomGenerator64Ptr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QRandomGenerator64
  (aSSIGN' arg'1' arg'2')

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

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

data QRandomGenerator64Const =
    QRandomGenerator64Const (HoppyF.Ptr QRandomGenerator64Const)
  | QRandomGenerator64ConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QRandomGenerator64Const)
  deriving (HoppyP.Show)

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

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

castQRandomGenerator64ToConst :: QRandomGenerator64 -> QRandomGenerator64Const
castQRandomGenerator64ToConst (QRandomGenerator64 ptr') = QRandomGenerator64Const $ HoppyF.castPtr ptr'
castQRandomGenerator64ToConst (QRandomGenerator64Gc fptr' ptr') = QRandomGenerator64ConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QRandomGenerator64Const QRandomGenerator64 where copy = newCopy

instance QRandomGenerator64ConstPtr QRandomGenerator64Const where
  toQRandomGenerator64Const = HoppyP.id

instance M118.QRandomGeneratorConstPtr QRandomGenerator64Const where
  toQRandomGeneratorConst (QRandomGenerator64Const ptr') = M118.QRandomGeneratorConst $ castQRandomGenerator64ToQRandomGenerator ptr'
  toQRandomGeneratorConst (QRandomGenerator64ConstGc fptr' ptr') = M118.QRandomGeneratorConstGc fptr' $ castQRandomGenerator64ToQRandomGenerator ptr'

data QRandomGenerator64 =
    QRandomGenerator64 (HoppyF.Ptr QRandomGenerator64)
  | QRandomGenerator64Gc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QRandomGenerator64)
  deriving (HoppyP.Show)

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

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

castQRandomGenerator64ToNonconst :: QRandomGenerator64Const -> QRandomGenerator64
castQRandomGenerator64ToNonconst (QRandomGenerator64Const ptr') = QRandomGenerator64 $ HoppyF.castPtr ptr'
castQRandomGenerator64ToNonconst (QRandomGenerator64ConstGc fptr' ptr') = QRandomGenerator64Gc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QRandomGenerator64 QRandomGenerator64 where copy = newCopy

instance QRandomGenerator64ConstPtr QRandomGenerator64 where
  toQRandomGenerator64Const (QRandomGenerator64 ptr') = QRandomGenerator64Const $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'
  toQRandomGenerator64Const (QRandomGenerator64Gc fptr' ptr') = QRandomGenerator64ConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'

instance QRandomGenerator64Ptr QRandomGenerator64 where
  toQRandomGenerator64 = HoppyP.id

instance M118.QRandomGeneratorConstPtr QRandomGenerator64 where
  toQRandomGeneratorConst (QRandomGenerator64 ptr') = M118.QRandomGeneratorConst $ castQRandomGenerator64ToQRandomGenerator $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'
  toQRandomGeneratorConst (QRandomGenerator64Gc fptr' ptr') = M118.QRandomGeneratorConstGc fptr' $ castQRandomGenerator64ToQRandomGenerator $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'

instance M118.QRandomGeneratorPtr QRandomGenerator64 where
  toQRandomGenerator (QRandomGenerator64 ptr') = M118.QRandomGenerator $ (HoppyF.castPtr :: HoppyF.Ptr M118.QRandomGeneratorConst -> HoppyF.Ptr M118.QRandomGenerator) $ castQRandomGenerator64ToQRandomGenerator $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'
  toQRandomGenerator (QRandomGenerator64Gc fptr' ptr') = M118.QRandomGeneratorGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M118.QRandomGeneratorConst -> HoppyF.Ptr M118.QRandomGenerator) $ castQRandomGenerator64ToQRandomGenerator $ (HoppyF.castPtr :: HoppyF.Ptr QRandomGenerator64 -> HoppyF.Ptr QRandomGenerator64Const) ptr'

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

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

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

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

newCopy :: (QRandomGenerator64Value arg'1) => (arg'1) -> (HoppyP.IO QRandomGenerator64)
newCopy arg'1 =
  withQRandomGenerator64Ptr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QRandomGenerator64
  (newCopy' arg'1')

class QRandomGenerator64Super a where
  downToQRandomGenerator64 :: a -> QRandomGenerator64


class QRandomGenerator64SuperConst a where
  downToQRandomGenerator64Const :: a -> QRandomGenerator64Const


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

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

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

instance HoppyFHR.Decodable QRandomGenerator64 (QRandomGenerator64) where
  decode = HoppyFHR.decode . toQRandomGenerator64Const

instance HoppyFHR.Decodable QRandomGenerator64Const (QRandomGenerator64) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc