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

module Graphics.UI.Qtah.Generated.Core.QFileInfo (
  QFileInfoValue (..),
  QFileInfoConstPtr (..),
  absoluteDir,
  absoluteFilePath,
  absolutePath,
  baseName,
  birthTime,
  bundleName,
  caching,
  canonicalFilePath,
  canonicalPath,
  completeBaseName,
  completeSuffix,
  dir,
  exists,
  fileName,
  filePath,
  fileTime,
  group,
  groupId,
  isAbsolute,
  isBundle,
  isDir,
  isExecutable,
  isFile,
  isHidden,
  isNativePath,
  isReadable,
  isRelative,
  isRoot,
  isSymLink,
  isWritable,
  lastModified,
  lastRead,
  metadataChangeTime,
  owner,
  ownerId,
  path,
  permission,
  permissions,
  size,
  suffix,
  symLinkTarget,
  eQ,
  nE,
  QFileInfoPtr (..),
  makeAbsolute,
  refresh,
  setCaching,
  setFileString,
  setFile,
  setFileDirAndString,
  swap,
  aSSIGN,
  existsStatic,
  QFileInfoConst (..),
  castQFileInfoToConst,
  QFileInfo (..),
  castQFileInfoToNonconst,
  new,
  newWithString,
  newWithFile,
  newWithDirAndString,
  newCopy,
  QFileInfoSuper (..),
  QFileInfoSuperConst (..),
  ) where

import Control.Monad ((>=>))
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.QDateTime as M24
import qualified Graphics.UI.Qtah.Generated.Core.QDir as M30
import qualified Graphics.UI.Qtah.Generated.Core.QFile as M36
import qualified Graphics.UI.Qtah.Generated.Core.QFileDevice as M38
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__QFileInfo_new" new' ::  HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "genpop__QFileInfo_newWithString" newWithString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "genpop__QFileInfo_newWithFile" newWithFile' ::  HoppyF.Ptr M36.QFileConst -> HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "genpop__QFileInfo_newWithDirAndString" newWithDirAndString' ::  HoppyF.Ptr M30.QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "genpop__QFileInfo_newCopy" newCopy' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "genpop__QFileInfo_absoluteDir" absoluteDir' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M30.QDirConst)
foreign import ccall "genpop__QFileInfo_absoluteFilePath" absoluteFilePath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_absolutePath" absolutePath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_baseName" baseName' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_birthTime" birthTime' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileInfo_bundleName" bundleName' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_caching" caching' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_canonicalFilePath" canonicalFilePath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_canonicalPath" canonicalPath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_completeBaseName" completeBaseName' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_completeSuffix" completeSuffix' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_dir" dir' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M30.QDirConst)
foreign import ccall "genpop__QFileInfo_exists" exists' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_existsStatic" existsStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_fileName" fileName' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_filePath" filePath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_fileTime" fileTime' ::  HoppyF.Ptr QFileInfoConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileInfo_group" group' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_groupId" groupId' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QFileInfo_isAbsolute" isAbsolute' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isBundle" isBundle' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isDir" isDir' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isExecutable" isExecutable' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isFile" isFile' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isHidden" isHidden' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isNativePath" isNativePath' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isReadable" isReadable' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isRelative" isRelative' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isRoot" isRoot' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isSymLink" isSymLink' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_isWritable" isWritable' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_lastModified" lastModified' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileInfo_lastRead" lastRead' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileInfo_makeAbsolute" makeAbsolute' ::  HoppyF.Ptr QFileInfo -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_metadataChangeTime" metadataChangeTime' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileInfo_owner" owner' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_ownerId" ownerId' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QFileInfo_path" path' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_permission" permission' ::  HoppyF.Ptr QFileInfoConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_permissions" permissions' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFileInfo_refresh" refresh' ::  HoppyF.Ptr QFileInfo -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_setCaching" setCaching' ::  HoppyF.Ptr QFileInfo -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_setFileString" setFileString' ::  HoppyF.Ptr QFileInfo -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_setFile" setFile' ::  HoppyF.Ptr QFileInfo -> HoppyF.Ptr M36.QFileConst -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_setFileDirAndString" setFileDirAndString' ::  HoppyF.Ptr QFileInfo -> HoppyF.Ptr M30.QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_size" size' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QFileInfo_suffix" suffix' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_swap" swap' ::  HoppyF.Ptr QFileInfo -> HoppyF.Ptr QFileInfo -> HoppyP.IO ()
foreign import ccall "genpop__QFileInfo_symLinkTarget" symLinkTarget' ::  HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileInfo_EQ" eQ' ::  HoppyF.Ptr QFileInfoConst -> HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_NE" nE' ::  HoppyF.Ptr QFileInfoConst -> HoppyF.Ptr QFileInfoConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileInfo_ASSIGN" aSSIGN' ::  HoppyF.Ptr QFileInfo -> HoppyF.Ptr QFileInfoConst -> HoppyP.IO (HoppyF.Ptr QFileInfo)
foreign import ccall "gendel__QFileInfo" delete'QFileInfo :: HoppyF.Ptr QFileInfoConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFileInfo" deletePtr'QFileInfo :: HoppyF.FunPtr (HoppyF.Ptr QFileInfoConst -> HoppyP.IO ())

class QFileInfoValue a where
  withQFileInfoPtr :: a -> (QFileInfoConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFileInfoConstPtr a => QFileInfoValue a where
  withQFileInfoPtr = HoppyP.flip ($) . toQFileInfoConst

class (HoppyFHR.CppPtr this) => QFileInfoConstPtr this where
  toQFileInfoConst :: this -> QFileInfoConst

absoluteDir :: (QFileInfoValue this) => (this) {- ^ this -} -> (HoppyP.IO M30.QDir)
absoluteDir arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M30.QDirConst) =<<
  (absoluteDir' arg'1')

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

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

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

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

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

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

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

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

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

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

dir :: (QFileInfoValue this) => (this) {- ^ this -} -> (HoppyP.IO M30.QDir)
dir arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M30.QDirConst) =<<
  (dir' arg'1')

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

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

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

fileTime :: (QFileInfoValue this) => (this) {- ^ this -} -> (M38.QFileDeviceFileTime) -> (HoppyP.IO M24.QDateTime)
fileTime arg'1 arg'2 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M24.QDateTimeConst) =<<
  (fileTime' arg'1' arg'2')

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

groupId :: (QFileInfoValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUInt)
groupId arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (groupId' arg'1')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ownerId :: (QFileInfoValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUInt)
ownerId arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (ownerId' arg'1')

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

permission :: (QFileInfoValue this, M38.IsQFileDevicePermissions arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
permission arg'1 arg'2 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M38.toQFileDevicePermissions
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (permission' arg'1' arg'2')

permissions :: (QFileInfoValue this) => (this) {- ^ this -} -> (HoppyP.IO M38.QFileDevicePermissions)
permissions arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (permissions' arg'1')

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

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

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

eQ :: (QFileInfoValue this, QFileInfoValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQFileInfoPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QFileInfoValue this, QFileInfoValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQFileInfoPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QFileInfoConstPtr this) => QFileInfoPtr this where
  toQFileInfo :: this -> QFileInfo

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

refresh :: (QFileInfoPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
refresh arg'1 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  (refresh' arg'1')

setCaching :: (QFileInfoPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setCaching arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setCaching' arg'1' arg'2')

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

setFile :: (QFileInfoPtr this, M36.QFileValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFile arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  M36.withQFilePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFile' arg'1' arg'2')

setFileDirAndString :: (QFileInfoPtr this, M30.QDirValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setFileDirAndString arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  M30.withQDirPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setFileDirAndString' arg'1' arg'2' arg'3')

swap :: (QFileInfoPtr this, QFileInfoPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQFileInfo arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QFileInfoPtr this, QFileInfoValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QFileInfo)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileInfo arg'1) $ \arg'1' ->
  withQFileInfoPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QFileInfo
  (aSSIGN' arg'1' arg'2')

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')

data QFileInfoConst =
    QFileInfoConst (HoppyF.Ptr QFileInfoConst)
  | QFileInfoConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileInfoConst)
  deriving (HoppyP.Show)

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

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

castQFileInfoToConst :: QFileInfo -> QFileInfoConst
castQFileInfoToConst (QFileInfo ptr') = QFileInfoConst $ HoppyF.castPtr ptr'
castQFileInfoToConst (QFileInfoGc fptr' ptr') = QFileInfoConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QFileInfoConst QFileInfo where copy = newCopy

instance QFileInfoConstPtr QFileInfoConst where
  toQFileInfoConst = HoppyP.id

data QFileInfo =
    QFileInfo (HoppyF.Ptr QFileInfo)
  | QFileInfoGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileInfo)
  deriving (HoppyP.Show)

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

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

castQFileInfoToNonconst :: QFileInfoConst -> QFileInfo
castQFileInfoToNonconst (QFileInfoConst ptr') = QFileInfo $ HoppyF.castPtr ptr'
castQFileInfoToNonconst (QFileInfoConstGc fptr' ptr') = QFileInfoGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QFileInfo QFileInfo where copy = newCopy

instance QFileInfoConstPtr QFileInfo where
  toQFileInfoConst (QFileInfo ptr') = QFileInfoConst $ (HoppyF.castPtr :: HoppyF.Ptr QFileInfo -> HoppyF.Ptr QFileInfoConst) ptr'
  toQFileInfoConst (QFileInfoGc fptr' ptr') = QFileInfoConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFileInfo -> HoppyF.Ptr QFileInfoConst) ptr'

instance QFileInfoPtr QFileInfo where
  toQFileInfo = HoppyP.id

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

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

newWithFile :: (M36.QFileValue arg'1) => (arg'1) -> (HoppyP.IO QFileInfo)
newWithFile arg'1 =
  M36.withQFilePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QFileInfo
  (newWithFile' arg'1')

newWithDirAndString :: (M30.QDirValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QFileInfo)
newWithDirAndString arg'1 arg'2 =
  M30.withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QFileInfo
  (newWithDirAndString' arg'1' arg'2')

newCopy :: (QFileInfoValue arg'1) => (arg'1) -> (HoppyP.IO QFileInfo)
newCopy arg'1 =
  withQFileInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QFileInfo
  (newCopy' arg'1')

class QFileInfoSuper a where
  downToQFileInfo :: a -> QFileInfo


class QFileInfoSuperConst a where
  downToQFileInfoConst :: a -> QFileInfoConst


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

instance QFileInfoValue a => HoppyFHR.Assignable QFileInfo a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QFileInfo (QFileInfo) where
  decode = HoppyFHR.decode . toQFileInfoConst

instance HoppyFHR.Decodable QFileInfoConst (QFileInfo) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc