QIODevice.hs

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

module Graphics.UI.Qtah.Generated.Core.QIODevice (
  castQIODeviceToQObject,
  castQObjectToQIODevice,
  QIODeviceValue (..),
  QIODeviceConstPtr (..),
  atEnd,
  bytesAvailable,
  bytesToWrite,
  canReadLine,
  currentReadChannel,
  currentWriteChannel,
  errorString,
  isOpen,
  isReadable,
  isSequential,
  isTextModeEnabled,
  isTransactionStarted,
  isWritable,
  openMode,
  pos,
  readChannelCount,
  size,
  writeChannelCount,
  QIODevicePtr (..),
  close,
  commitTransaction,
  open,
  peekByteArray,
  peekRaw,
  putChar,
  readByteArray,
  readRaw,
  readAll,
  readLineByteArray,
  readLineByteArrayWithSize,
  readLineRaw,
  reset,
  rollbackTransaction,
  seek,
  setCurrentReadChannel,
  setCurrentWriteChannel,
  setTextModeEnabled,
  skip,
  startTransaction,
  ungetChar,
  waitForBytesWritten,
  waitForReadyRead,
  writeByteArray,
  writeRaw,
  writeRawWithSize,
  emitAboutToClose,
  emitBytesWritten,
  emitChannelBytesWritten,
  emitChannelReadyRead,
  emitReadChannelFinished,
  emitReadyRead,
  QIODeviceConst (..),
  castQIODeviceToConst,
  QIODevice (..),
  castQIODeviceToNonconst,
  QIODeviceSuper (..),
  QIODeviceSuperConst (..),
  QIODeviceOpenMode,
  IsQIODeviceOpenMode (..),
  append,
  existingOnly,
  newOnly,
  notOpen,
  readOnly,
  readWrite,
  text,
  truncate,
  unbuffered,
  writeOnly,
  QIODeviceOpenModeFlag (..),
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
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 Foreign.Hoppy.Runtime as QtahFHR
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.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__QIODevice_atEnd" atEnd' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_bytesAvailable" bytesAvailable' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_bytesToWrite" bytesToWrite' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_canReadLine" canReadLine' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_close" close' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_commitTransaction" commitTransaction' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_currentReadChannel" currentReadChannel' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QIODevice_currentWriteChannel" currentWriteChannel' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QIODevice_errorString" errorString' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QIODevice_isOpen" isOpen' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_isReadable" isReadable' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_isSequential" isSequential' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_isTextModeEnabled" isTextModeEnabled' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_isTransactionStarted" isTransactionStarted' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_isWritable" isWritable' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_open" open' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_openMode" openMode' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QIODevice_peekByteArray" peekByteArray' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QIODevice_peekRaw" peekRaw' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr HoppyFC.CChar -> HoppyDI.Int64 -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_pos" pos' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_putChar" putChar' ::  HoppyF.Ptr QIODevice -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_readByteArray" readByteArray' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QIODevice_readRaw" readRaw' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr HoppyFC.CChar -> HoppyDI.Int64 -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_readAll" readAll' ::  HoppyF.Ptr QIODevice -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QIODevice_readChannelCount" readChannelCount' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QIODevice_readLineByteArray" readLineByteArray' ::  HoppyF.Ptr QIODevice -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QIODevice_readLineByteArrayWithSize" readLineByteArrayWithSize' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QIODevice_readLineRaw" readLineRaw' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr HoppyFC.CChar -> HoppyDI.Int64 -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_reset" reset' ::  HoppyF.Ptr QIODevice -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_rollbackTransaction" rollbackTransaction' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_seek" seek' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_setCurrentReadChannel" setCurrentReadChannel' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_setCurrentWriteChannel" setCurrentWriteChannel' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_setTextModeEnabled" setTextModeEnabled' ::  HoppyF.Ptr QIODevice -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_size" size' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_skip" skip' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_startTransaction" startTransaction' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_ungetChar" ungetChar' ::  HoppyF.Ptr QIODevice -> HoppyFC.CChar -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_waitForBytesWritten" waitForBytesWritten' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_waitForReadyRead" waitForReadyRead' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QIODevice_writeByteArray" writeByteArray' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_writeRaw" writeRaw' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_writeRawWithSize" writeRawWithSize' ::  HoppyF.Ptr QIODevice -> HoppyF.Ptr HoppyFC.CChar -> HoppyDI.Int64 -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QIODevice_writeChannelCount" writeChannelCount' ::  HoppyF.Ptr QIODeviceConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QIODevice_emitAboutToClose" emitAboutToClose' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_emitBytesWritten" emitBytesWritten' ::  HoppyF.Ptr QIODevice -> HoppyDI.Int64 -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_emitChannelBytesWritten" emitChannelBytesWritten' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_emitChannelReadyRead" emitChannelReadyRead' ::  HoppyF.Ptr QIODevice -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_emitReadChannelFinished" emitReadChannelFinished' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QIODevice_emitReadyRead" emitReadyRead' ::  HoppyF.Ptr QIODevice -> HoppyP.IO ()
foreign import ccall "gencast__QIODevice__QObject" castQIODeviceToQObject :: HoppyF.Ptr QIODeviceConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QIODevice" castQObjectToQIODevice :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QIODeviceConst
foreign import ccall "gendel__QIODevice" delete'QIODevice :: HoppyF.Ptr QIODeviceConst -> HoppyP.IO ()
foreign import ccall "&gendel__QIODevice" deletePtr'QIODevice :: HoppyF.FunPtr (HoppyF.Ptr QIODeviceConst -> HoppyP.IO ())

class QIODeviceValue a where
  withQIODevicePtr :: a -> (QIODeviceConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QIODeviceConstPtr a => QIODeviceValue a where
  withQIODevicePtr = HoppyP.flip ($) . toQIODeviceConst

class (M94.QObjectConstPtr this) => QIODeviceConstPtr this where
  toQIODeviceConst :: this -> QIODeviceConst

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

bytesAvailable :: (QIODeviceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
bytesAvailable arg'1 =
  withQIODevicePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (bytesAvailable' arg'1')

bytesToWrite :: (QIODeviceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
bytesToWrite arg'1 =
  withQIODevicePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (bytesToWrite' arg'1')

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

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

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

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

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

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

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

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

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

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

openMode :: (QIODeviceValue this) => (this) {- ^ this -} -> (HoppyP.IO QIODeviceOpenMode)
openMode arg'1 =
  withQIODevicePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (openMode' arg'1')

pos :: (QIODeviceValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
pos arg'1 =
  withQIODevicePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (pos' arg'1')

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

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

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

class (QIODeviceConstPtr this, M94.QObjectPtr this) => QIODevicePtr this where
  toQIODevice :: this -> QIODevice

close :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
close arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (close' arg'1')

commitTransaction :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
commitTransaction arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (commitTransaction' arg'1')

open :: (QIODevicePtr this, IsQIODeviceOpenMode arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
open arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQIODeviceOpenMode
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (open' arg'1' arg'2')

peekByteArray :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QtahDBS.ByteString)
peekByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (peekByteArray' arg'1' arg'2')

peekRaw :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyDI.Int64) -> (HoppyP.IO HoppyDI.Int64)
peekRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (peekRaw' arg'1' arg'2' arg'3')

putChar :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Bool)
putChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (putChar' arg'1' arg'2')

readByteArray :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QtahDBS.ByteString)
readByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readByteArray' arg'1' arg'2')

readRaw :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyDI.Int64) -> (HoppyP.IO HoppyDI.Int64)
readRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (readRaw' arg'1' arg'2' arg'3')

readAll :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
readAll arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readAll' arg'1')

readLineByteArray :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
readLineByteArray arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readLineByteArray' arg'1')

readLineByteArrayWithSize :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO QtahDBS.ByteString)
readLineByteArrayWithSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readLineByteArrayWithSize' arg'1' arg'2')

readLineRaw :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyDI.Int64) -> (HoppyP.IO HoppyDI.Int64)
readLineRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (readLineRaw' arg'1' arg'2' arg'3')

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

rollbackTransaction :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
rollbackTransaction arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (rollbackTransaction' arg'1')

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

setCurrentReadChannel :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setCurrentReadChannel arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setCurrentReadChannel' arg'1' arg'2')

setCurrentWriteChannel :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setCurrentWriteChannel arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setCurrentWriteChannel' arg'1' arg'2')

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

skip :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO HoppyDI.Int64)
skip arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (skip' arg'1' arg'2')

startTransaction :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
startTransaction arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (startTransaction' arg'1')

ungetChar :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO ())
ungetChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (ungetChar' arg'1' arg'2')

waitForBytesWritten :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForBytesWritten arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForBytesWritten' arg'1' arg'2')

waitForReadyRead :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForReadyRead arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForReadyRead' arg'1' arg'2')

writeByteArray :: (QIODevicePtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyDI.Int64)
writeByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (writeByteArray' arg'1' arg'2')

writeRaw :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyDI.Int64)
writeRaw arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (writeRaw' arg'1' arg'2')

writeRawWithSize :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyDI.Int64) -> (HoppyP.IO HoppyDI.Int64)
writeRawWithSize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (writeRawWithSize' arg'1' arg'2' arg'3')

emitAboutToClose :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitAboutToClose arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (emitAboutToClose' arg'1')

emitBytesWritten :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyDI.Int64) -> (HoppyP.IO ())
emitBytesWritten arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (emitBytesWritten' arg'1' arg'2')

emitChannelBytesWritten :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyDI.Int64) -> (HoppyP.IO ())
emitChannelBytesWritten arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (emitChannelBytesWritten' arg'1' arg'2' arg'3')

emitChannelReadyRead :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitChannelReadyRead arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitChannelReadyRead' arg'1' arg'2')

emitReadChannelFinished :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitReadChannelFinished arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (emitReadChannelFinished' arg'1')

emitReadyRead :: (QIODevicePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitReadyRead arg'1 =
  HoppyFHR.withCppPtr (toQIODevice arg'1) $ \arg'1' ->
  (emitReadyRead' arg'1')

data QIODeviceConst =
    QIODeviceConst (HoppyF.Ptr QIODeviceConst)
  | QIODeviceConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QIODeviceConst)
  deriving (HoppyP.Show)

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

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

castQIODeviceToConst :: QIODevice -> QIODeviceConst
castQIODeviceToConst (QIODevice ptr') = QIODeviceConst $ HoppyF.castPtr ptr'
castQIODeviceToConst (QIODeviceGc fptr' ptr') = QIODeviceConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QIODeviceConstPtr QIODeviceConst where
  toQIODeviceConst = HoppyP.id

instance M94.QObjectConstPtr QIODeviceConst where
  toQObjectConst (QIODeviceConst ptr') = M94.QObjectConst $ castQIODeviceToQObject ptr'
  toQObjectConst (QIODeviceConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQIODeviceToQObject ptr'

data QIODevice =
    QIODevice (HoppyF.Ptr QIODevice)
  | QIODeviceGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QIODevice)
  deriving (HoppyP.Show)

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

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

castQIODeviceToNonconst :: QIODeviceConst -> QIODevice
castQIODeviceToNonconst (QIODeviceConst ptr') = QIODevice $ HoppyF.castPtr ptr'
castQIODeviceToNonconst (QIODeviceConstGc fptr' ptr') = QIODeviceGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QIODeviceConstPtr QIODevice where
  toQIODeviceConst (QIODevice ptr') = QIODeviceConst $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'
  toQIODeviceConst (QIODeviceGc fptr' ptr') = QIODeviceConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'

instance QIODevicePtr QIODevice where
  toQIODevice = HoppyP.id

instance M94.QObjectConstPtr QIODevice where
  toQObjectConst (QIODevice ptr') = M94.QObjectConst $ castQIODeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'
  toQObjectConst (QIODeviceGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQIODeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'

instance M94.QObjectPtr QIODevice where
  toQObject (QIODevice ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQIODeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'
  toQObject (QIODeviceGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQIODeviceToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QIODevice -> HoppyF.Ptr QIODeviceConst) ptr'

class QIODeviceSuper a where
  downToQIODevice :: a -> QIODevice

instance QIODeviceSuper M94.QObject where
  downToQIODevice = castQIODeviceToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QIODeviceConst $ castQObjectToQIODevice ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QIODeviceConstGc fptr' $ castQObjectToQIODevice ptr'

class QIODeviceSuperConst a where
  downToQIODeviceConst :: a -> QIODeviceConst

instance QIODeviceSuperConst M94.QObjectConst where
  downToQIODeviceConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QIODeviceConst $ castQObjectToQIODevice ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QIODeviceConstGc fptr' $ castQObjectToQIODevice ptr'

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

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

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

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

class IsQIODeviceOpenMode a where
  toQIODeviceOpenMode :: a -> QIODeviceOpenMode

instance IsQIODeviceOpenMode QIODeviceOpenMode where toQIODeviceOpenMode = QtahP.id
instance IsQIODeviceOpenMode QIODeviceOpenModeFlag where toQIODeviceOpenMode = QtahFlags.enumToFlags
instance IsQIODeviceOpenMode (HoppyFC.CInt) where toQIODeviceOpenMode = QtahFlags.numToFlags

append :: QIODeviceOpenMode
append = QIODeviceOpenMode (4)

existingOnly :: QIODeviceOpenMode
existingOnly = QIODeviceOpenMode (128)

newOnly :: QIODeviceOpenMode
newOnly = QIODeviceOpenMode (64)

notOpen :: QIODeviceOpenMode
notOpen = QIODeviceOpenMode (0)

readOnly :: QIODeviceOpenMode
readOnly = QIODeviceOpenMode (1)

readWrite :: QIODeviceOpenMode
readWrite = QIODeviceOpenMode (3)

text :: QIODeviceOpenMode
text = QIODeviceOpenMode (16)

truncate :: QIODeviceOpenMode
truncate = QIODeviceOpenMode (8)

unbuffered :: QIODeviceOpenMode
unbuffered = QIODeviceOpenMode (32)

writeOnly :: QIODeviceOpenMode
writeOnly = QIODeviceOpenMode (2)

instance QtahDB.Bits QIODeviceOpenMode 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 QIODeviceOpenModeFlag =
  NotOpen
  | ReadOnly
  | WriteOnly
  | ReadWrite
  | Append
  | Truncate
  | Text
  | Unbuffered
  | NewOnly
  | ExistingOnly
  | UnknownQioDeviceOpenModeFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QIODeviceOpenModeFlag where
  fromCppEnum NotOpen = 0
  fromCppEnum ReadOnly = 1
  fromCppEnum WriteOnly = 2
  fromCppEnum ReadWrite = 3
  fromCppEnum Append = 4
  fromCppEnum Truncate = 8
  fromCppEnum Text = 16
  fromCppEnum Unbuffered = 32
  fromCppEnum NewOnly = 64
  fromCppEnum ExistingOnly = 128
  fromCppEnum (UnknownQioDeviceOpenModeFlag n) = n
  
  toCppEnum (0) = NotOpen
  toCppEnum (1) = ReadOnly
  toCppEnum (2) = WriteOnly
  toCppEnum (3) = ReadWrite
  toCppEnum (4) = Append
  toCppEnum (8) = Truncate
  toCppEnum (16) = Text
  toCppEnum (32) = Unbuffered
  toCppEnum (64) = NewOnly
  toCppEnum (128) = ExistingOnly
  toCppEnum n = UnknownQioDeviceOpenModeFlag n

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

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