QOperatingSystemVersion.hs

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

module Graphics.UI.Qtah.Generated.Core.QOperatingSystemVersion (
  QOperatingSystemVersionValue (..),
  QOperatingSystemVersionConstPtr (..),
  majorVersion,
  microVersion,
  minorVersion,
  name,
  segmentCount,
  getType,
  QOperatingSystemVersionPtr (..),
  current,
  currentType,
  QOperatingSystemVersionConst (..),
  castQOperatingSystemVersionToConst,
  QOperatingSystemVersion (..),
  castQOperatingSystemVersionToNonconst,
  new,
  newWithMinor,
  newWithMinorAndMicro,
  newCopy,
  QOperatingSystemVersionSuper (..),
  QOperatingSystemVersionSuperConst (..),
  QOperatingSystemVersionOSType (..),
  ) where

import Control.Monad ((>=>))
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.QString as M142
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QOperatingSystemVersion_new" new' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QOperatingSystemVersion)
foreign import ccall "genpop__QOperatingSystemVersion_newWithMinor" newWithMinor' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QOperatingSystemVersion)
foreign import ccall "genpop__QOperatingSystemVersion_newWithMinorAndMicro" newWithMinorAndMicro' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QOperatingSystemVersion)
foreign import ccall "genpop__QOperatingSystemVersion_newCopy" newCopy' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO (HoppyF.Ptr QOperatingSystemVersion)
foreign import ccall "genpop__QOperatingSystemVersion_current" current' ::  HoppyP.IO (HoppyF.Ptr QOperatingSystemVersionConst)
foreign import ccall "genpop__QOperatingSystemVersion_currentType" currentType' ::  HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOperatingSystemVersion_majorVersion" majorVersion' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOperatingSystemVersion_microVersion" microVersion' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOperatingSystemVersion_minorVersion" minorVersion' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOperatingSystemVersion_name" name' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QOperatingSystemVersion_segmentCount" segmentCount' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOperatingSystemVersion_getType" getType' ::  HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "gendel__QOperatingSystemVersion" delete'QOperatingSystemVersion :: HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO ()
foreign import ccall "&gendel__QOperatingSystemVersion" deletePtr'QOperatingSystemVersion :: HoppyF.FunPtr (HoppyF.Ptr QOperatingSystemVersionConst -> HoppyP.IO ())

class QOperatingSystemVersionValue a where
  withQOperatingSystemVersionPtr :: a -> (QOperatingSystemVersionConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QOperatingSystemVersionConstPtr a => QOperatingSystemVersionValue a where
  withQOperatingSystemVersionPtr = HoppyP.flip ($) . toQOperatingSystemVersionConst

class (HoppyFHR.CppPtr this) => QOperatingSystemVersionConstPtr this where
  toQOperatingSystemVersionConst :: this -> QOperatingSystemVersionConst

majorVersion :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
majorVersion arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (majorVersion' arg'1')

microVersion :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
microVersion arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (microVersion' arg'1')

minorVersion :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
minorVersion arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (minorVersion' arg'1')

name :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
name arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (name' arg'1')

segmentCount :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
segmentCount arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (segmentCount' arg'1')

getType :: (QOperatingSystemVersionValue this) => (this) {- ^ this -} -> (HoppyP.IO QOperatingSystemVersionOSType)
getType arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (getType' arg'1')

class (QOperatingSystemVersionConstPtr this) => QOperatingSystemVersionPtr this where
  toQOperatingSystemVersion :: this -> QOperatingSystemVersion

current :: (HoppyP.IO QOperatingSystemVersion)
current =
  (HoppyFHR.decodeAndDelete . QOperatingSystemVersionConst) =<<
  (current')

currentType :: (HoppyP.IO QOperatingSystemVersionOSType)
currentType =
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (currentType')

data QOperatingSystemVersionConst =
    QOperatingSystemVersionConst (HoppyF.Ptr QOperatingSystemVersionConst)
  | QOperatingSystemVersionConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QOperatingSystemVersionConst)
  deriving (HoppyP.Show)

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

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

castQOperatingSystemVersionToConst :: QOperatingSystemVersion -> QOperatingSystemVersionConst
castQOperatingSystemVersionToConst (QOperatingSystemVersion ptr') = QOperatingSystemVersionConst $ HoppyF.castPtr ptr'
castQOperatingSystemVersionToConst (QOperatingSystemVersionGc fptr' ptr') = QOperatingSystemVersionConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QOperatingSystemVersionConst QOperatingSystemVersion where copy = newCopy

instance QOperatingSystemVersionConstPtr QOperatingSystemVersionConst where
  toQOperatingSystemVersionConst = HoppyP.id

data QOperatingSystemVersion =
    QOperatingSystemVersion (HoppyF.Ptr QOperatingSystemVersion)
  | QOperatingSystemVersionGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QOperatingSystemVersion)
  deriving (HoppyP.Show)

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

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

castQOperatingSystemVersionToNonconst :: QOperatingSystemVersionConst -> QOperatingSystemVersion
castQOperatingSystemVersionToNonconst (QOperatingSystemVersionConst ptr') = QOperatingSystemVersion $ HoppyF.castPtr ptr'
castQOperatingSystemVersionToNonconst (QOperatingSystemVersionConstGc fptr' ptr') = QOperatingSystemVersionGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QOperatingSystemVersion QOperatingSystemVersion where copy = newCopy

instance QOperatingSystemVersionConstPtr QOperatingSystemVersion where
  toQOperatingSystemVersionConst (QOperatingSystemVersion ptr') = QOperatingSystemVersionConst $ (HoppyF.castPtr :: HoppyF.Ptr QOperatingSystemVersion -> HoppyF.Ptr QOperatingSystemVersionConst) ptr'
  toQOperatingSystemVersionConst (QOperatingSystemVersionGc fptr' ptr') = QOperatingSystemVersionConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QOperatingSystemVersion -> HoppyF.Ptr QOperatingSystemVersionConst) ptr'

instance QOperatingSystemVersionPtr QOperatingSystemVersion where
  toQOperatingSystemVersion = HoppyP.id

new :: (QOperatingSystemVersionOSType) -> (HoppyP.Int) -> (HoppyP.IO QOperatingSystemVersion)
new arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QOperatingSystemVersion
  (new' arg'1' arg'2')

newWithMinor :: (QOperatingSystemVersionOSType) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QOperatingSystemVersion)
newWithMinor arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QOperatingSystemVersion
  (newWithMinor' arg'1' arg'2' arg'3')

newWithMinorAndMicro :: (QOperatingSystemVersionOSType) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QOperatingSystemVersion)
newWithMinorAndMicro arg'1 arg'2 arg'3 arg'4 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QOperatingSystemVersion
  (newWithMinorAndMicro' arg'1' arg'2' arg'3' arg'4')

newCopy :: (QOperatingSystemVersionValue arg'1) => (arg'1) -> (HoppyP.IO QOperatingSystemVersion)
newCopy arg'1 =
  withQOperatingSystemVersionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QOperatingSystemVersion
  (newCopy' arg'1')

class QOperatingSystemVersionSuper a where
  downToQOperatingSystemVersion :: a -> QOperatingSystemVersion


class QOperatingSystemVersionSuperConst a where
  downToQOperatingSystemVersionConst :: a -> QOperatingSystemVersionConst


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

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

instance HoppyFHR.Decodable QOperatingSystemVersion (QOperatingSystemVersion) where
  decode = HoppyFHR.decode . toQOperatingSystemVersionConst

instance HoppyFHR.Decodable QOperatingSystemVersionConst (QOperatingSystemVersion) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QOperatingSystemVersionOSType =
  Unknown
  | Windows
  | MacOs
  | Ios
  | TvOs
  | WatchOs
  | Android
  | UnknownQOperatingSystemVersionOsType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QOperatingSystemVersionOSType where
  fromCppEnum Unknown = 0
  fromCppEnum Windows = 1
  fromCppEnum MacOs = 2
  fromCppEnum Ios = 3
  fromCppEnum TvOs = 4
  fromCppEnum WatchOs = 5
  fromCppEnum Android = 6
  fromCppEnum (UnknownQOperatingSystemVersionOsType n) = n
  
  toCppEnum (0) = Unknown
  toCppEnum (1) = Windows
  toCppEnum (2) = MacOs
  toCppEnum (3) = Ios
  toCppEnum (4) = TvOs
  toCppEnum (5) = WatchOs
  toCppEnum (6) = Android
  toCppEnum n = UnknownQOperatingSystemVersionOsType n

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

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