QResource.hs

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

module Graphics.UI.Qtah.Generated.Core.QResource (
  QResourceValue (..),
  QResourceConstPtr (..),
  absoluteFilePath,
  compressionAlgorithm,
  getData,
  fileName,
  isCompressed,
  isValid,
  lastModified,
  size,
  QResourcePtr (..),
  setFileName,
  registerResourcePath,
  registerResourcePathAndTree,
  registerResourceData,
  registerResourceDataAndTree,
  unregisterResourcePath,
  unregisterResourcePathAndTree,
  unregisterResourceData,
  unregisterResourceDataAndTree,
  QResourceConst (..),
  castQResourceToConst,
  QResource (..),
  castQResourceToNonconst,
  new,
  newWithFile,
  QResourceSuper (..),
  QResourceSuperConst (..),
  QResourceCompression (..),
  ) where

import qualified Data.Int as HoppyDI
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.QDateTime as M24
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__QResource_new" new' ::  HoppyP.IO (HoppyF.Ptr QResource)
foreign import ccall "genpop__QResource_newWithFile" newWithFile' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QResource)
foreign import ccall "genpop__QResource_absoluteFilePath" absoluteFilePath' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QResource_compressionAlgorithm" compressionAlgorithm' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QResource_getData" getData' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QResource_fileName" fileName' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QResource_isCompressed" isCompressed' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_isValid" isValid' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_lastModified" lastModified' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QResource_registerResourcePath" registerResourcePath' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_registerResourcePathAndTree" registerResourcePathAndTree' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_registerResourceData" registerResourceData' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_registerResourceDataAndTree" registerResourceDataAndTree' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_setFileName" setFileName' ::  HoppyF.Ptr QResource -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QResource_size" size' ::  HoppyF.Ptr QResourceConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QResource_unregisterResourcePath" unregisterResourcePath' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_unregisterResourcePathAndTree" unregisterResourcePathAndTree' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_unregisterResourceData" unregisterResourceData' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QResource_unregisterResourceDataAndTree" unregisterResourceDataAndTree' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QResource" delete'QResource :: HoppyF.Ptr QResourceConst -> HoppyP.IO ()
foreign import ccall "&gendel__QResource" deletePtr'QResource :: HoppyF.FunPtr (HoppyF.Ptr QResourceConst -> HoppyP.IO ())

class QResourceValue a where
  withQResourcePtr :: a -> (QResourceConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QResourceConstPtr a => QResourceValue a where
  withQResourcePtr = HoppyP.flip ($) . toQResourceConst

class (HoppyFHR.CppPtr this) => QResourceConstPtr this where
  toQResourceConst :: this -> QResourceConst

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

compressionAlgorithm :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO QResourceCompression)
compressionAlgorithm arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (compressionAlgorithm' arg'1')

getData :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
getData arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (getData' arg'1')

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

isCompressed :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isCompressed arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isCompressed' arg'1')

isValid :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isValid arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isValid' arg'1')

lastModified :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO M24.QDateTime)
lastModified arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M24.QDateTimeConst) =<<
  (lastModified' arg'1')

size :: (QResourceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
size arg'1 =
  withQResourcePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (size' arg'1')

class (QResourceConstPtr this) => QResourcePtr this where
  toQResource :: this -> QResource

setFileName :: (QResourcePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFileName arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQResource arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFileName' arg'1' arg'2')

registerResourcePath :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
registerResourcePath arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (registerResourcePath' arg'1')

registerResourcePathAndTree :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
registerResourcePathAndTree arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (registerResourcePathAndTree' arg'1' arg'2')

registerResourceData :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.IO HoppyP.Bool)
registerResourceData arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (registerResourceData' arg'1')

registerResourceDataAndTree :: (M142.QStringValue arg'2) => (HoppyF.Ptr HoppyFC.CUChar) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
registerResourceDataAndTree arg'1 arg'2 =
  let arg'1' = arg'1 in
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (registerResourceDataAndTree' arg'1' arg'2')

unregisterResourcePath :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
unregisterResourcePath arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unregisterResourcePath' arg'1')

unregisterResourcePathAndTree :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
unregisterResourcePathAndTree arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unregisterResourcePathAndTree' arg'1' arg'2')

unregisterResourceData :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.IO HoppyP.Bool)
unregisterResourceData arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unregisterResourceData' arg'1')

unregisterResourceDataAndTree :: (M142.QStringValue arg'2) => (HoppyF.Ptr HoppyFC.CUChar) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
unregisterResourceDataAndTree arg'1 arg'2 =
  let arg'1' = arg'1 in
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unregisterResourceDataAndTree' arg'1' arg'2')

data QResourceConst =
    QResourceConst (HoppyF.Ptr QResourceConst)
  | QResourceConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QResourceConst)
  deriving (HoppyP.Show)

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

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

castQResourceToConst :: QResource -> QResourceConst
castQResourceToConst (QResource ptr') = QResourceConst $ HoppyF.castPtr ptr'
castQResourceToConst (QResourceGc fptr' ptr') = QResourceConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QResourceConstPtr QResourceConst where
  toQResourceConst = HoppyP.id

data QResource =
    QResource (HoppyF.Ptr QResource)
  | QResourceGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QResource)
  deriving (HoppyP.Show)

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

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

castQResourceToNonconst :: QResourceConst -> QResource
castQResourceToNonconst (QResourceConst ptr') = QResource $ HoppyF.castPtr ptr'
castQResourceToNonconst (QResourceConstGc fptr' ptr') = QResourceGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QResourceConstPtr QResource where
  toQResourceConst (QResource ptr') = QResourceConst $ (HoppyF.castPtr :: HoppyF.Ptr QResource -> HoppyF.Ptr QResourceConst) ptr'
  toQResourceConst (QResourceGc fptr' ptr') = QResourceConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QResource -> HoppyF.Ptr QResourceConst) ptr'

instance QResourcePtr QResource where
  toQResource = HoppyP.id

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

newWithFile :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QResource)
newWithFile arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QResource
  (newWithFile' arg'1')

class QResourceSuper a where
  downToQResource :: a -> QResource


class QResourceSuperConst a where
  downToQResourceConst :: a -> QResourceConst


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

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

data QResourceCompression =
  NoCompression
  | ZlibCompression
  | ZstdCompression
  | UnknownQResourceCompression (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QResourceCompression where
  fromCppEnum NoCompression = 0
  fromCppEnum ZlibCompression = 1
  fromCppEnum ZstdCompression = 2
  fromCppEnum (UnknownQResourceCompression n) = n
  
  toCppEnum (0) = NoCompression
  toCppEnum (1) = ZlibCompression
  toCppEnum (2) = ZstdCompression
  toCppEnum n = UnknownQResourceCompression n

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

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