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

module Graphics.UI.Qtah.Generated.Core.QFile (
  castQFileToQFileDevice,
  castQFileDeviceToQFile,
  castQFileToQIODevice,
  castQIODeviceToQFile,
  castQFileToQObject,
  castQObjectToQFile,
  QFileValue (..),
  QFileConstPtr (..),
  exists,
  symLinkTarget,
  QFilePtr (..),
  copy,
  link,
  openWithFileDesc,
  openWithFileDescAndFlags,
  remove,
  rename,
  setFileName,
  copyStatic,
  decodeName,
  encodeName,
  existsStatic,
  linkStatic,
  permissionsStatic,
  removeStatic,
  renameStatic,
  resizeStatic,
  setPermissionsStatic,
  symLinkTargetStatic,
  QFileConst (..),
  castQFileToConst,
  QFile (..),
  castQFileToNonconst,
  new,
  newWithParent,
  newWithName,
  newWithNameAndParent,
  QFileSuper (..),
  QFileSuperConst (..),
  ) where

import qualified Data.ByteString as QtahDBS
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.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QFileDevice as M38
import qualified Graphics.UI.Qtah.Generated.Core.QIODevice as M48
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
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__QFile_new" new' ::  HoppyP.IO (HoppyF.Ptr QFile)
foreign import ccall "genpop__QFile_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QFile)
foreign import ccall "genpop__QFile_newWithName" newWithName' ::  HoppyF.Ptr M142.QString -> HoppyP.IO (HoppyF.Ptr QFile)
foreign import ccall "genpop__QFile_newWithNameAndParent" newWithNameAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QFile)
foreign import ccall "genpop__QFile_copy" copy' ::  HoppyF.Ptr QFile -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_copyStatic" copyStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_decodeName" decodeName' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFile_encodeName" encodeName' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QFile_exists" exists' ::  HoppyF.Ptr QFileConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_existsStatic" existsStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_link" link' ::  HoppyF.Ptr QFile -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_linkStatic" linkStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_openWithFileDesc" openWithFileDesc' ::  HoppyF.Ptr QFile -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_openWithFileDescAndFlags" openWithFileDescAndFlags' ::  HoppyF.Ptr QFile -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_permissionsStatic" permissionsStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFile_remove" remove' ::  HoppyF.Ptr QFile -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_removeStatic" removeStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_rename" rename' ::  HoppyF.Ptr QFile -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_renameStatic" renameStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_resizeStatic" resizeStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyDI.Int64 -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_setFileName" setFileName' ::  HoppyF.Ptr QFile -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QFile_setPermissionsStatic" setPermissionsStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFile_symLinkTargetStatic" symLinkTargetStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFile_symLinkTarget" symLinkTarget' ::  HoppyF.Ptr QFileConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gencast__QFile__QFileDevice" castQFileToQFileDevice :: HoppyF.Ptr QFileConst -> HoppyF.Ptr M38.QFileDeviceConst
foreign import ccall "gencast__QFileDevice__QFile" castQFileDeviceToQFile :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr QFileConst
foreign import ccall "gencast__QFile__QIODevice" castQFileToQIODevice :: HoppyF.Ptr QFileConst -> HoppyF.Ptr M48.QIODeviceConst
foreign import ccall "gencast__QIODevice__QFile" castQIODeviceToQFile :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr QFileConst
foreign import ccall "gencast__QFile__QObject" castQFileToQObject :: HoppyF.Ptr QFileConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QFile" castQObjectToQFile :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QFileConst
foreign import ccall "gendel__QFile" delete'QFile :: HoppyF.Ptr QFileConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFile" deletePtr'QFile :: HoppyF.FunPtr (HoppyF.Ptr QFileConst -> HoppyP.IO ())

class QFileValue a where
  withQFilePtr :: a -> (QFileConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFileConstPtr a => QFileValue a where
  withQFilePtr = HoppyP.flip ($) . toQFileConst

class (M38.QFileDeviceConstPtr this) => QFileConstPtr this where
  toQFileConst :: this -> QFileConst

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

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

class (QFileConstPtr this, M38.QFileDevicePtr this) => QFilePtr this where
  toQFile :: this -> QFile

copy :: (QFilePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
copy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (copy' arg'1' arg'2')

link :: (QFilePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
link arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (link' arg'1' arg'2')

openWithFileDesc :: (QFilePtr this, M48.IsQIODeviceOpenMode arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
openWithFileDesc arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (openWithFileDesc' arg'1' arg'2' arg'3')

openWithFileDescAndFlags :: (QFilePtr this, M48.IsQIODeviceOpenMode arg'3, M38.IsQFileDeviceFileHandleFlags arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (arg'4) -> (HoppyP.IO HoppyP.Bool)
openWithFileDescAndFlags arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M38.toQFileDeviceFileHandleFlags
  ) arg'4 >>= \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (openWithFileDescAndFlags' arg'1' arg'2' arg'3' arg'4')

remove :: (QFilePtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
remove arg'1 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (remove' arg'1')

rename :: (QFilePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
rename arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFile arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (rename' arg'1' arg'2')

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

copyStatic :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
copyStatic 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))
  ) =<<
  (copyStatic' arg'1' arg'2')

decodeName :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
decodeName arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (decodeName' arg'1')

encodeName :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahDBS.ByteString)
encodeName arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (encodeName' arg'1')

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

linkStatic :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
linkStatic 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))
  ) =<<
  (linkStatic' arg'1' arg'2')

permissionsStatic :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO M38.QFileDevicePermissions)
permissionsStatic arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (permissionsStatic' arg'1')

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

renameStatic :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
renameStatic 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))
  ) =<<
  (renameStatic' arg'1' arg'2')

resizeStatic :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyDI.Int64) -> (HoppyP.IO HoppyP.Bool)
resizeStatic arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (resizeStatic' arg'1' arg'2')

setPermissionsStatic :: (M142.QStringValue arg'1, M38.IsQFileDevicePermissions arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
setPermissionsStatic arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M38.toQFileDevicePermissions
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (setPermissionsStatic' arg'1' arg'2')

symLinkTargetStatic :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
symLinkTargetStatic arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (symLinkTargetStatic' arg'1')

data QFileConst =
    QFileConst (HoppyF.Ptr QFileConst)
  | QFileConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileConst)
  deriving (HoppyP.Show)

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

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

castQFileToConst :: QFile -> QFileConst
castQFileToConst (QFile ptr') = QFileConst $ HoppyF.castPtr ptr'
castQFileToConst (QFileGc fptr' ptr') = QFileConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileConstPtr QFileConst where
  toQFileConst = HoppyP.id

instance M38.QFileDeviceConstPtr QFileConst where
  toQFileDeviceConst (QFileConst ptr') = M38.QFileDeviceConst $ castQFileToQFileDevice ptr'
  toQFileDeviceConst (QFileConstGc fptr' ptr') = M38.QFileDeviceConstGc fptr' $ castQFileToQFileDevice ptr'

instance M48.QIODeviceConstPtr QFileConst where
  toQIODeviceConst (QFileConst ptr') = M48.QIODeviceConst $ castQFileToQIODevice ptr'
  toQIODeviceConst (QFileConstGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQFileToQIODevice ptr'

instance M94.QObjectConstPtr QFileConst where
  toQObjectConst (QFileConst ptr') = M94.QObjectConst $ castQFileToQObject ptr'
  toQObjectConst (QFileConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileToQObject ptr'

data QFile =
    QFile (HoppyF.Ptr QFile)
  | QFileGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFile)
  deriving (HoppyP.Show)

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

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

castQFileToNonconst :: QFileConst -> QFile
castQFileToNonconst (QFileConst ptr') = QFile $ HoppyF.castPtr ptr'
castQFileToNonconst (QFileConstGc fptr' ptr') = QFileGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileConstPtr QFile where
  toQFileConst (QFile ptr') = QFileConst $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQFileConst (QFileGc fptr' ptr') = QFileConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance QFilePtr QFile where
  toQFile = HoppyP.id

instance M38.QFileDeviceConstPtr QFile where
  toQFileDeviceConst (QFile ptr') = M38.QFileDeviceConst $ castQFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQFileDeviceConst (QFileGc fptr' ptr') = M38.QFileDeviceConstGc fptr' $ castQFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance M38.QFileDevicePtr QFile where
  toQFileDevice (QFile ptr') = M38.QFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr M38.QFileDevice) $ castQFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQFileDevice (QFileGc fptr' ptr') = M38.QFileDeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr M38.QFileDevice) $ castQFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance M48.QIODeviceConstPtr QFile where
  toQIODeviceConst (QFile ptr') = M48.QIODeviceConst $ castQFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQIODeviceConst (QFileGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance M48.QIODevicePtr QFile where
  toQIODevice (QFile ptr') = M48.QIODevice $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQIODevice (QFileGc fptr' ptr') = M48.QIODeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance M94.QObjectConstPtr QFile where
  toQObjectConst (QFile ptr') = M94.QObjectConst $ castQFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQObjectConst (QFileGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

instance M94.QObjectPtr QFile where
  toQObject (QFile ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'
  toQObject (QFileGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFile -> HoppyF.Ptr QFileConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QFile)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QFile
  (newWithParent' arg'1')

newWithName :: (M142.QStringPtr arg'1) => (arg'1) -> (HoppyP.IO QFile)
newWithName arg'1 =
  HoppyFHR.withCppPtr (M142.toQString arg'1) $ \arg'1' ->
  HoppyP.fmap QFile
  (newWithName' arg'1')

newWithNameAndParent :: (M142.QStringValue arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QFile)
newWithNameAndParent arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QFile
  (newWithNameAndParent' arg'1' arg'2')

class QFileSuper a where
  downToQFile :: a -> QFile

instance QFileSuper M38.QFileDevice where
  downToQFile = castQFileToNonconst . cast' . M38.castQFileDeviceToConst
    where
      cast' (M38.QFileDeviceConst ptr') = QFileConst $ castQFileDeviceToQFile ptr'
      cast' (M38.QFileDeviceConstGc fptr' ptr') = QFileConstGc fptr' $ castQFileDeviceToQFile ptr'
instance QFileSuper M48.QIODevice where
  downToQFile = castQFileToNonconst . cast' . M48.castQIODeviceToConst
    where
      cast' (M48.QIODeviceConst ptr') = QFileConst $ castQIODeviceToQFile ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QFileConstGc fptr' $ castQIODeviceToQFile ptr'
instance QFileSuper M94.QObject where
  downToQFile = castQFileToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QFileConst $ castQObjectToQFile ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileConstGc fptr' $ castQObjectToQFile ptr'

class QFileSuperConst a where
  downToQFileConst :: a -> QFileConst

instance QFileSuperConst M38.QFileDeviceConst where
  downToQFileConst = cast'
    where
      cast' (M38.QFileDeviceConst ptr') = QFileConst $ castQFileDeviceToQFile ptr'
      cast' (M38.QFileDeviceConstGc fptr' ptr') = QFileConstGc fptr' $ castQFileDeviceToQFile ptr'
instance QFileSuperConst M48.QIODeviceConst where
  downToQFileConst = cast'
    where
      cast' (M48.QIODeviceConst ptr') = QFileConst $ castQIODeviceToQFile ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QFileConstGc fptr' $ castQIODeviceToQFile ptr'
instance QFileSuperConst M94.QObjectConst where
  downToQFileConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QFileConst $ castQObjectToQFile ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileConstGc fptr' $ castQObjectToQFile ptr'

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

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