QSysInfo.hs

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

module Graphics.UI.Qtah.Generated.Core.QSysInfo (
  QSysInfoValue (..),
  QSysInfoConstPtr (..),
  QSysInfoPtr (..),
  bootUniqueId,
  buildAbi,
  buildCpuArchitecture,
  currentCpuArchitecture,
  kernelType,
  kernelVersion,
  machineHostName,
  machineUniqueId,
  prettyProductName,
  productType,
  productVersion,
  QSysInfoConst (..),
  castQSysInfoToConst,
  QSysInfo (..),
  castQSysInfoToNonconst,
  QSysInfoSuper (..),
  QSysInfoSuperConst (..),
  QSysInfoEndian (..),
  QSysInfoSizes (..),
  ) 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.QString as M142
import Prelude (($), (.), (=<<), (==))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QSysInfo_bootUniqueId" bootUniqueId' ::  HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QSysInfo_buildAbi" buildAbi' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_buildCpuArchitecture" buildCpuArchitecture' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_currentCpuArchitecture" currentCpuArchitecture' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_kernelType" kernelType' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_kernelVersion" kernelVersion' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_machineHostName" machineHostName' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_machineUniqueId" machineUniqueId' ::  HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QSysInfo_prettyProductName" prettyProductName' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_productType" productType' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSysInfo_productVersion" productVersion' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gendel__QSysInfo" delete'QSysInfo :: HoppyF.Ptr QSysInfoConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSysInfo" deletePtr'QSysInfo :: HoppyF.FunPtr (HoppyF.Ptr QSysInfoConst -> HoppyP.IO ())

class QSysInfoValue a where
  withQSysInfoPtr :: a -> (QSysInfoConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QSysInfoConstPtr a => QSysInfoValue a where
  withQSysInfoPtr = HoppyP.flip ($) . toQSysInfoConst

class (HoppyFHR.CppPtr this) => QSysInfoConstPtr this where
  toQSysInfoConst :: this -> QSysInfoConst

class (QSysInfoConstPtr this) => QSysInfoPtr this where
  toQSysInfo :: this -> QSysInfo

bootUniqueId :: (HoppyP.IO QtahDBS.ByteString)
bootUniqueId =
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (bootUniqueId')

buildAbi :: (HoppyP.IO QtahP.String)
buildAbi =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (buildAbi')

buildCpuArchitecture :: (HoppyP.IO QtahP.String)
buildCpuArchitecture =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (buildCpuArchitecture')

currentCpuArchitecture :: (HoppyP.IO QtahP.String)
currentCpuArchitecture =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (currentCpuArchitecture')

kernelType :: (HoppyP.IO QtahP.String)
kernelType =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (kernelType')

kernelVersion :: (HoppyP.IO QtahP.String)
kernelVersion =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (kernelVersion')

machineHostName :: (HoppyP.IO QtahP.String)
machineHostName =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (machineHostName')

machineUniqueId :: (HoppyP.IO QtahDBS.ByteString)
machineUniqueId =
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (machineUniqueId')

prettyProductName :: (HoppyP.IO QtahP.String)
prettyProductName =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (prettyProductName')

productType :: (HoppyP.IO QtahP.String)
productType =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (productType')

productVersion :: (HoppyP.IO QtahP.String)
productVersion =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (productVersion')

data QSysInfoConst =
    QSysInfoConst (HoppyF.Ptr QSysInfoConst)
  | QSysInfoConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSysInfoConst)
  deriving (HoppyP.Show)

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

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

castQSysInfoToConst :: QSysInfo -> QSysInfoConst
castQSysInfoToConst (QSysInfo ptr') = QSysInfoConst $ HoppyF.castPtr ptr'
castQSysInfoToConst (QSysInfoGc fptr' ptr') = QSysInfoConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSysInfoConstPtr QSysInfoConst where
  toQSysInfoConst = HoppyP.id

data QSysInfo =
    QSysInfo (HoppyF.Ptr QSysInfo)
  | QSysInfoGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSysInfo)
  deriving (HoppyP.Show)

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

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

castQSysInfoToNonconst :: QSysInfoConst -> QSysInfo
castQSysInfoToNonconst (QSysInfoConst ptr') = QSysInfo $ HoppyF.castPtr ptr'
castQSysInfoToNonconst (QSysInfoConstGc fptr' ptr') = QSysInfoGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSysInfoConstPtr QSysInfo where
  toQSysInfoConst (QSysInfo ptr') = QSysInfoConst $ (HoppyF.castPtr :: HoppyF.Ptr QSysInfo -> HoppyF.Ptr QSysInfoConst) ptr'
  toQSysInfoConst (QSysInfoGc fptr' ptr') = QSysInfoConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSysInfo -> HoppyF.Ptr QSysInfoConst) ptr'

instance QSysInfoPtr QSysInfo where
  toQSysInfo = HoppyP.id

class QSysInfoSuper a where
  downToQSysInfo :: a -> QSysInfo


class QSysInfoSuperConst a where
  downToQSysInfoConst :: a -> QSysInfoConst


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

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

data QSysInfoEndian =
  BigEndian
  | LittleEndian
  | ByteOrder
  | UnknownQSysInfoEndian (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSysInfoEndian where
  fromCppEnum BigEndian = 0
  fromCppEnum LittleEndian = 1
  fromCppEnum ByteOrder = 1
  fromCppEnum (UnknownQSysInfoEndian n) = n
  
  toCppEnum (0) = BigEndian
  toCppEnum (1) = ByteOrder
  toCppEnum n = UnknownQSysInfoEndian n

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

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

data QSysInfoSizes =
  WordSize
  | UnknownQSysInfoSizes (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSysInfoSizes where
  fromCppEnum WordSize = 64
  fromCppEnum (UnknownQSysInfoSizes n) = n
  
  toCppEnum (64) = WordSize
  toCppEnum n = UnknownQSysInfoSizes n

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

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