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

module Graphics.UI.Qtah.Generated.Core.QLibraryInfo (
  QLibraryInfoValue (..),
  QLibraryInfoConstPtr (..),
  QLibraryInfoPtr (..),
  isDebugBuild,
  location,
  version,
  QLibraryInfoConst (..),
  castQLibraryInfoToConst,
  QLibraryInfo (..),
  castQLibraryInfoToNonconst,
  QLibraryInfoSuper (..),
  QLibraryInfoSuperConst (..),
  QLibraryInfoLibraryLocation (..),
  ) where

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 qualified Graphics.UI.Qtah.Generated.Core.QVersionNumber as M172
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QLibraryInfo_isDebugBuild" isDebugBuild' ::  HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLibraryInfo_location" location' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLibraryInfo_version" version' ::  HoppyP.IO (HoppyF.Ptr M172.QVersionNumberConst)
foreign import ccall "gendel__QLibraryInfo" delete'QLibraryInfo :: HoppyF.Ptr QLibraryInfoConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLibraryInfo" deletePtr'QLibraryInfo :: HoppyF.FunPtr (HoppyF.Ptr QLibraryInfoConst -> HoppyP.IO ())

class QLibraryInfoValue a where
  withQLibraryInfoPtr :: a -> (QLibraryInfoConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLibraryInfoConstPtr a => QLibraryInfoValue a where
  withQLibraryInfoPtr = HoppyP.flip ($) . toQLibraryInfoConst

class (HoppyFHR.CppPtr this) => QLibraryInfoConstPtr this where
  toQLibraryInfoConst :: this -> QLibraryInfoConst

class (QLibraryInfoConstPtr this) => QLibraryInfoPtr this where
  toQLibraryInfo :: this -> QLibraryInfo

isDebugBuild :: (HoppyP.IO HoppyP.Bool)
isDebugBuild =
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isDebugBuild')

location :: (QLibraryInfoLibraryLocation) -> (HoppyP.IO QtahP.String)
location arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (location' arg'1')

version :: (HoppyP.IO M172.QVersionNumber)
version =
  (HoppyFHR.decodeAndDelete . M172.QVersionNumberConst) =<<
  (version')

data QLibraryInfoConst =
    QLibraryInfoConst (HoppyF.Ptr QLibraryInfoConst)
  | QLibraryInfoConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLibraryInfoConst)
  deriving (HoppyP.Show)

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

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

castQLibraryInfoToConst :: QLibraryInfo -> QLibraryInfoConst
castQLibraryInfoToConst (QLibraryInfo ptr') = QLibraryInfoConst $ HoppyF.castPtr ptr'
castQLibraryInfoToConst (QLibraryInfoGc fptr' ptr') = QLibraryInfoConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLibraryInfoConstPtr QLibraryInfoConst where
  toQLibraryInfoConst = HoppyP.id

data QLibraryInfo =
    QLibraryInfo (HoppyF.Ptr QLibraryInfo)
  | QLibraryInfoGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLibraryInfo)
  deriving (HoppyP.Show)

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

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

castQLibraryInfoToNonconst :: QLibraryInfoConst -> QLibraryInfo
castQLibraryInfoToNonconst (QLibraryInfoConst ptr') = QLibraryInfo $ HoppyF.castPtr ptr'
castQLibraryInfoToNonconst (QLibraryInfoConstGc fptr' ptr') = QLibraryInfoGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLibraryInfoConstPtr QLibraryInfo where
  toQLibraryInfoConst (QLibraryInfo ptr') = QLibraryInfoConst $ (HoppyF.castPtr :: HoppyF.Ptr QLibraryInfo -> HoppyF.Ptr QLibraryInfoConst) ptr'
  toQLibraryInfoConst (QLibraryInfoGc fptr' ptr') = QLibraryInfoConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLibraryInfo -> HoppyF.Ptr QLibraryInfoConst) ptr'

instance QLibraryInfoPtr QLibraryInfo where
  toQLibraryInfo = HoppyP.id

class QLibraryInfoSuper a where
  downToQLibraryInfo :: a -> QLibraryInfo


class QLibraryInfoSuperConst a where
  downToQLibraryInfoConst :: a -> QLibraryInfoConst


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

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

data QLibraryInfoLibraryLocation =
  PrefixPath
  | DocumentationPath
  | HeadersPath
  | LibrariesPath
  | LibraryExecutablesPath
  | BinariesPath
  | PluginsPath
  | ImportsPath
  | Qml2ImportsPath
  | ArchDataPath
  | DataPath
  | TranslationsPath
  | ExamplesPath
  | TestsPath
  | SettingsPath
  | UnknownQLibraryInfoLibraryLocation (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLibraryInfoLibraryLocation where
  fromCppEnum PrefixPath = 0
  fromCppEnum DocumentationPath = 1
  fromCppEnum HeadersPath = 2
  fromCppEnum LibrariesPath = 3
  fromCppEnum LibraryExecutablesPath = 4
  fromCppEnum BinariesPath = 5
  fromCppEnum PluginsPath = 6
  fromCppEnum ImportsPath = 7
  fromCppEnum Qml2ImportsPath = 8
  fromCppEnum ArchDataPath = 9
  fromCppEnum DataPath = 10
  fromCppEnum TranslationsPath = 11
  fromCppEnum ExamplesPath = 12
  fromCppEnum TestsPath = 13
  fromCppEnum SettingsPath = 100
  fromCppEnum (UnknownQLibraryInfoLibraryLocation n) = n
  
  toCppEnum (0) = PrefixPath
  toCppEnum (1) = DocumentationPath
  toCppEnum (2) = HeadersPath
  toCppEnum (3) = LibrariesPath
  toCppEnum (4) = LibraryExecutablesPath
  toCppEnum (5) = BinariesPath
  toCppEnum (6) = PluginsPath
  toCppEnum (7) = ImportsPath
  toCppEnum (8) = Qml2ImportsPath
  toCppEnum (9) = ArchDataPath
  toCppEnum (10) = DataPath
  toCppEnum (11) = TranslationsPath
  toCppEnum (12) = ExamplesPath
  toCppEnum (13) = TestsPath
  toCppEnum (100) = SettingsPath
  toCppEnum n = UnknownQLibraryInfoLibraryLocation n

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

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