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

module Graphics.UI.Qtah.Generated.Core.QFileDevice (
  castQFileDeviceToQIODevice,
  castQIODeviceToQFileDevice,
  castQFileDeviceToQObject,
  castQObjectToQFileDevice,
  QFileDeviceValue (..),
  QFileDeviceConstPtr (..),
  error,
  fileName,
  fileTime,
  handle,
  permissions,
  QFileDevicePtr (..),
  flush,
  map,
  mapWithFlags,
  resize,
  setFileTime,
  setPermissions,
  unmap,
  unsetError,
  QFileDeviceConst (..),
  castQFileDeviceToConst,
  QFileDevice (..),
  castQFileDeviceToNonconst,
  QFileDeviceSuper (..),
  QFileDeviceSuperConst (..),
  QFileDeviceFileError (..),
  QFileDeviceFileHandleFlag (..),
  QFileDeviceFileHandleFlags,
  IsQFileDeviceFileHandleFlags (..),
  autoCloseHandle,
  dontCloseHandle,
  QFileDeviceFileTime (..),
  QFileDeviceMemoryMapFlags (..),
  QFileDevicePermission (..),
  QFileDevicePermissions,
  IsQFileDevicePermissions (..),
  exeGroup,
  exeOther,
  exeOwner,
  exeUser,
  readGroup,
  readOther,
  readOwner,
  readUser,
  writeGroup,
  writeOther,
  writeOwner,
  writeUser,
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
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 Foreign.Hoppy.Runtime as QtahFHR
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.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__QFileDevice_error" error' ::  HoppyF.Ptr QFileDeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFileDevice_fileName" fileName' ::  HoppyF.Ptr QFileDeviceConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileDevice_fileTime" fileTime' ::  HoppyF.Ptr QFileDeviceConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M24.QDateTimeConst)
foreign import ccall "genpop__QFileDevice_flush" flush' ::  HoppyF.Ptr QFileDevice -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileDevice_handle" handle' ::  HoppyF.Ptr QFileDeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFileDevice_map" map' ::  HoppyF.Ptr QFileDevice -> HoppyDI.Int64 -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QFileDevice_mapWithFlags" mapWithFlags' ::  HoppyF.Ptr QFileDevice -> HoppyDI.Int64 -> HoppyDI.Int64 -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QFileDevice_permissions" permissions' ::  HoppyF.Ptr QFileDeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFileDevice_resize" resize' ::  HoppyF.Ptr QFileDevice -> HoppyDI.Int64 -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileDevice_setFileTime" setFileTime' ::  HoppyF.Ptr QFileDevice -> HoppyF.Ptr M24.QDateTimeConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileDevice_setPermissions" setPermissions' ::  HoppyF.Ptr QFileDevice -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileDevice_unmap" unmap' ::  HoppyF.Ptr QFileDevice -> HoppyF.Ptr HoppyFC.CUChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileDevice_unsetError" unsetError' ::  HoppyF.Ptr QFileDevice -> HoppyP.IO ()
foreign import ccall "gencast__QFileDevice__QIODevice" castQFileDeviceToQIODevice :: HoppyF.Ptr QFileDeviceConst -> HoppyF.Ptr M48.QIODeviceConst
foreign import ccall "gencast__QIODevice__QFileDevice" castQIODeviceToQFileDevice :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr QFileDeviceConst
foreign import ccall "gencast__QFileDevice__QObject" castQFileDeviceToQObject :: HoppyF.Ptr QFileDeviceConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QFileDevice" castQObjectToQFileDevice :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QFileDeviceConst
foreign import ccall "gendel__QFileDevice" delete'QFileDevice :: HoppyF.Ptr QFileDeviceConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFileDevice" deletePtr'QFileDevice :: HoppyF.FunPtr (HoppyF.Ptr QFileDeviceConst -> HoppyP.IO ())

class QFileDeviceValue a where
  withQFileDevicePtr :: a -> (QFileDeviceConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFileDeviceConstPtr a => QFileDeviceValue a where
  withQFileDevicePtr = HoppyP.flip ($) . toQFileDeviceConst

class (M48.QIODeviceConstPtr this) => QFileDeviceConstPtr this where
  toQFileDeviceConst :: this -> QFileDeviceConst

error :: (QFileDeviceValue this) => (this) {- ^ this -} -> (HoppyP.IO QFileDeviceFileError)
error arg'1 =
  withQFileDevicePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (error' arg'1')

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

fileTime :: (QFileDeviceValue this) => (this) {- ^ this -} -> (QFileDeviceFileTime) -> (HoppyP.IO M24.QDateTime)
fileTime arg'1 arg'2 =
  withQFileDevicePtr 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')

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

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

class (QFileDeviceConstPtr this, M48.QIODevicePtr this) => QFileDevicePtr this where
  toQFileDevice :: this -> QFileDevice

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

map :: (QFileDevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyDI.Int64) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
map arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (map' arg'1' arg'2' arg'3')

mapWithFlags :: (QFileDevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyDI.Int64) -> (QFileDeviceMemoryMapFlags) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
mapWithFlags arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (mapWithFlags' arg'1' arg'2' arg'3' arg'4')

resize :: (QFileDevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO HoppyP.Bool)
resize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (resize' arg'1' arg'2')

setFileTime :: (QFileDevicePtr this, M24.QDateTimeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QFileDeviceFileTime) -> (HoppyP.IO HoppyP.Bool)
setFileTime arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  M24.withQDateTimePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (setFileTime' arg'1' arg'2' arg'3')

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

unmap :: (QFileDevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.IO HoppyP.Bool)
unmap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unmap' arg'1' arg'2')

unsetError :: (QFileDevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unsetError arg'1 =
  HoppyFHR.withCppPtr (toQFileDevice arg'1) $ \arg'1' ->
  (unsetError' arg'1')

data QFileDeviceConst =
    QFileDeviceConst (HoppyF.Ptr QFileDeviceConst)
  | QFileDeviceConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileDeviceConst)
  deriving (HoppyP.Show)

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

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

castQFileDeviceToConst :: QFileDevice -> QFileDeviceConst
castQFileDeviceToConst (QFileDevice ptr') = QFileDeviceConst $ HoppyF.castPtr ptr'
castQFileDeviceToConst (QFileDeviceGc fptr' ptr') = QFileDeviceConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileDeviceConstPtr QFileDeviceConst where
  toQFileDeviceConst = HoppyP.id

instance M48.QIODeviceConstPtr QFileDeviceConst where
  toQIODeviceConst (QFileDeviceConst ptr') = M48.QIODeviceConst $ castQFileDeviceToQIODevice ptr'
  toQIODeviceConst (QFileDeviceConstGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQFileDeviceToQIODevice ptr'

instance M94.QObjectConstPtr QFileDeviceConst where
  toQObjectConst (QFileDeviceConst ptr') = M94.QObjectConst $ castQFileDeviceToQObject ptr'
  toQObjectConst (QFileDeviceConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileDeviceToQObject ptr'

data QFileDevice =
    QFileDevice (HoppyF.Ptr QFileDevice)
  | QFileDeviceGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileDevice)
  deriving (HoppyP.Show)

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

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

castQFileDeviceToNonconst :: QFileDeviceConst -> QFileDevice
castQFileDeviceToNonconst (QFileDeviceConst ptr') = QFileDevice $ HoppyF.castPtr ptr'
castQFileDeviceToNonconst (QFileDeviceConstGc fptr' ptr') = QFileDeviceGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileDeviceConstPtr QFileDevice where
  toQFileDeviceConst (QFileDevice ptr') = QFileDeviceConst $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'
  toQFileDeviceConst (QFileDeviceGc fptr' ptr') = QFileDeviceConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'

instance QFileDevicePtr QFileDevice where
  toQFileDevice = HoppyP.id

instance M48.QIODeviceConstPtr QFileDevice where
  toQIODeviceConst (QFileDevice ptr') = M48.QIODeviceConst $ castQFileDeviceToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'
  toQIODeviceConst (QFileDeviceGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQFileDeviceToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'

instance M48.QIODevicePtr QFileDevice where
  toQIODevice (QFileDevice ptr') = M48.QIODevice $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQFileDeviceToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'
  toQIODevice (QFileDeviceGc fptr' ptr') = M48.QIODeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQFileDeviceToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'

instance M94.QObjectConstPtr QFileDevice where
  toQObjectConst (QFileDevice ptr') = M94.QObjectConst $ castQFileDeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'
  toQObjectConst (QFileDeviceGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileDeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'

instance M94.QObjectPtr QFileDevice where
  toQObject (QFileDevice ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileDeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'
  toQObject (QFileDeviceGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileDeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileDevice -> HoppyF.Ptr QFileDeviceConst) ptr'

class QFileDeviceSuper a where
  downToQFileDevice :: a -> QFileDevice

instance QFileDeviceSuper M48.QIODevice where
  downToQFileDevice = castQFileDeviceToNonconst . cast' . M48.castQIODeviceToConst
    where
      cast' (M48.QIODeviceConst ptr') = QFileDeviceConst $ castQIODeviceToQFileDevice ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QFileDeviceConstGc fptr' $ castQIODeviceToQFileDevice ptr'
instance QFileDeviceSuper M94.QObject where
  downToQFileDevice = castQFileDeviceToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QFileDeviceConst $ castQObjectToQFileDevice ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileDeviceConstGc fptr' $ castQObjectToQFileDevice ptr'

class QFileDeviceSuperConst a where
  downToQFileDeviceConst :: a -> QFileDeviceConst

instance QFileDeviceSuperConst M48.QIODeviceConst where
  downToQFileDeviceConst = cast'
    where
      cast' (M48.QIODeviceConst ptr') = QFileDeviceConst $ castQIODeviceToQFileDevice ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QFileDeviceConstGc fptr' $ castQIODeviceToQFileDevice ptr'
instance QFileDeviceSuperConst M94.QObjectConst where
  downToQFileDeviceConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QFileDeviceConst $ castQObjectToQFileDevice ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileDeviceConstGc fptr' $ castQObjectToQFileDevice ptr'

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

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

data QFileDeviceFileError =
  NoError
  | ReadError
  | WriteError
  | FatalError
  | ResourceError
  | OpenError
  | AbortError
  | TimeOutError
  | UnspecifiedError
  | RemoveError
  | RenameError
  | PositionError
  | ResizeError
  | PermissionsError
  | CopyError
  | UnknownQFileDeviceFileError (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFileDeviceFileError where
  fromCppEnum NoError = 0
  fromCppEnum ReadError = 1
  fromCppEnum WriteError = 2
  fromCppEnum FatalError = 3
  fromCppEnum ResourceError = 4
  fromCppEnum OpenError = 5
  fromCppEnum AbortError = 6
  fromCppEnum TimeOutError = 7
  fromCppEnum UnspecifiedError = 8
  fromCppEnum RemoveError = 9
  fromCppEnum RenameError = 10
  fromCppEnum PositionError = 11
  fromCppEnum ResizeError = 12
  fromCppEnum PermissionsError = 13
  fromCppEnum CopyError = 14
  fromCppEnum (UnknownQFileDeviceFileError n) = n
  
  toCppEnum (0) = NoError
  toCppEnum (1) = ReadError
  toCppEnum (2) = WriteError
  toCppEnum (3) = FatalError
  toCppEnum (4) = ResourceError
  toCppEnum (5) = OpenError
  toCppEnum (6) = AbortError
  toCppEnum (7) = TimeOutError
  toCppEnum (8) = UnspecifiedError
  toCppEnum (9) = RemoveError
  toCppEnum (10) = RenameError
  toCppEnum (11) = PositionError
  toCppEnum (12) = ResizeError
  toCppEnum (13) = PermissionsError
  toCppEnum (14) = CopyError
  toCppEnum n = UnknownQFileDeviceFileError n

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

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

data QFileDeviceFileHandleFlag =
  DontCloseHandle
  | AutoCloseHandle
  | UnknownQFileDeviceFileHandleFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFileDeviceFileHandleFlag where
  fromCppEnum DontCloseHandle = 0
  fromCppEnum AutoCloseHandle = 1
  fromCppEnum (UnknownQFileDeviceFileHandleFlag n) = n
  
  toCppEnum (0) = DontCloseHandle
  toCppEnum (1) = AutoCloseHandle
  toCppEnum n = UnknownQFileDeviceFileHandleFlag n

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

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

newtype QFileDeviceFileHandleFlags = QFileDeviceFileHandleFlags (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QFileDeviceFileHandleFlag QFileDeviceFileHandleFlags where
  enumToFlags = QFileDeviceFileHandleFlags . QtahFHR.fromCppEnum
  flagsToEnum (QFileDeviceFileHandleFlags x') = QtahFHR.toCppEnum x'

class IsQFileDeviceFileHandleFlags a where
  toQFileDeviceFileHandleFlags :: a -> QFileDeviceFileHandleFlags

instance IsQFileDeviceFileHandleFlags QFileDeviceFileHandleFlags where toQFileDeviceFileHandleFlags = QtahP.id
instance IsQFileDeviceFileHandleFlags QFileDeviceFileHandleFlag where toQFileDeviceFileHandleFlags = QtahFlags.enumToFlags
instance IsQFileDeviceFileHandleFlags (HoppyFC.CInt) where toQFileDeviceFileHandleFlags = QtahFlags.numToFlags

autoCloseHandle :: QFileDeviceFileHandleFlags
autoCloseHandle = QFileDeviceFileHandleFlags (1)

dontCloseHandle :: QFileDeviceFileHandleFlags
dontCloseHandle = QFileDeviceFileHandleFlags (0)

instance QtahDB.Bits QFileDeviceFileHandleFlags where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum

data QFileDeviceFileTime =
  FileAccessTime
  | FileBirthTime
  | FileMetadataChangeTime
  | FileModificationTime
  | UnknownQFileDeviceFileTime (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFileDeviceFileTime where
  fromCppEnum FileAccessTime = 0
  fromCppEnum FileBirthTime = 1
  fromCppEnum FileMetadataChangeTime = 2
  fromCppEnum FileModificationTime = 3
  fromCppEnum (UnknownQFileDeviceFileTime n) = n
  
  toCppEnum (0) = FileAccessTime
  toCppEnum (1) = FileBirthTime
  toCppEnum (2) = FileMetadataChangeTime
  toCppEnum (3) = FileModificationTime
  toCppEnum n = UnknownQFileDeviceFileTime n

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

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

data QFileDeviceMemoryMapFlags =
  NoOptions
  | MapPrivateOption
  | UnknownQFileDeviceMemoryMapFlags (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFileDeviceMemoryMapFlags where
  fromCppEnum NoOptions = 0
  fromCppEnum MapPrivateOption = 1
  fromCppEnum (UnknownQFileDeviceMemoryMapFlags n) = n
  
  toCppEnum (0) = NoOptions
  toCppEnum (1) = MapPrivateOption
  toCppEnum n = UnknownQFileDeviceMemoryMapFlags n

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

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

data QFileDevicePermission =
  ReadOwner
  | WriteOwner
  | ExeOwner
  | ReadUser
  | WriteUser
  | ExeUser
  | ReadGroup
  | WriteGroup
  | ExeGroup
  | ReadOther
  | WriteOther
  | ExeOther
  | UnknownQFileDevicePermission (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFileDevicePermission where
  fromCppEnum ReadOwner = 16384
  fromCppEnum WriteOwner = 8192
  fromCppEnum ExeOwner = 4096
  fromCppEnum ReadUser = 1024
  fromCppEnum WriteUser = 512
  fromCppEnum ExeUser = 256
  fromCppEnum ReadGroup = 64
  fromCppEnum WriteGroup = 32
  fromCppEnum ExeGroup = 16
  fromCppEnum ReadOther = 4
  fromCppEnum WriteOther = 2
  fromCppEnum ExeOther = 1
  fromCppEnum (UnknownQFileDevicePermission n) = n
  
  toCppEnum (1) = ExeOther
  toCppEnum (2) = WriteOther
  toCppEnum (4) = ReadOther
  toCppEnum (16) = ExeGroup
  toCppEnum (32) = WriteGroup
  toCppEnum (64) = ReadGroup
  toCppEnum (256) = ExeUser
  toCppEnum (512) = WriteUser
  toCppEnum (1024) = ReadUser
  toCppEnum (4096) = ExeOwner
  toCppEnum (8192) = WriteOwner
  toCppEnum (16384) = ReadOwner
  toCppEnum n = UnknownQFileDevicePermission n

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

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

newtype QFileDevicePermissions = QFileDevicePermissions (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QFileDevicePermission QFileDevicePermissions where
  enumToFlags = QFileDevicePermissions . QtahFHR.fromCppEnum
  flagsToEnum (QFileDevicePermissions x') = QtahFHR.toCppEnum x'

class IsQFileDevicePermissions a where
  toQFileDevicePermissions :: a -> QFileDevicePermissions

instance IsQFileDevicePermissions QFileDevicePermissions where toQFileDevicePermissions = QtahP.id
instance IsQFileDevicePermissions QFileDevicePermission where toQFileDevicePermissions = QtahFlags.enumToFlags
instance IsQFileDevicePermissions (HoppyFC.CInt) where toQFileDevicePermissions = QtahFlags.numToFlags

exeGroup :: QFileDevicePermissions
exeGroup = QFileDevicePermissions (16)

exeOther :: QFileDevicePermissions
exeOther = QFileDevicePermissions (1)

exeOwner :: QFileDevicePermissions
exeOwner = QFileDevicePermissions (4096)

exeUser :: QFileDevicePermissions
exeUser = QFileDevicePermissions (256)

readGroup :: QFileDevicePermissions
readGroup = QFileDevicePermissions (64)

readOther :: QFileDevicePermissions
readOther = QFileDevicePermissions (4)

readOwner :: QFileDevicePermissions
readOwner = QFileDevicePermissions (16384)

readUser :: QFileDevicePermissions
readUser = QFileDevicePermissions (1024)

writeGroup :: QFileDevicePermissions
writeGroup = QFileDevicePermissions (32)

writeOther :: QFileDevicePermissions
writeOther = QFileDevicePermissions (2)

writeOwner :: QFileDevicePermissions
writeOwner = QFileDevicePermissions (8192)

writeUser :: QFileDevicePermissions
writeUser = QFileDevicePermissions (512)

instance QtahDB.Bits QFileDevicePermissions where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum