QXmlStreamReader.hs

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

module Graphics.UI.Qtah.Generated.Core.QXmlStreamReader (
  QXmlStreamReaderValue (..),
  QXmlStreamReaderConstPtr (..),
  namespaceProcessing,
  atEnd,
  attributes,
  characterOffset,
  columnNumber,
  device,
  entityDeclarations,
  entityResolver,
  error,
  errorString,
  hasError,
  isCDATA,
  isCharacters,
  isComment,
  isDTD,
  isEndDocument,
  isEndElement,
  isEntityReference,
  isProcessingInstruction,
  isStandaloneDocument,
  isStartDocument,
  isStartElement,
  isWhitespace,
  lineNumber,
  namespaceDeclarations,
  notationDeclarations,
  tokenString,
  tokenType,
  QXmlStreamReaderPtr (..),
  setNamespaceProcessing,
  addDataWithByteArray,
  addDataWithString,
  addDataWithPtrChar,
  addExtraNamespaceDeclaration,
  addExtraNamespaceDeclarations,
  clear,
  setDevice,
  setEntityResolver,
  raiseError,
  raiseErrorWithMessage,
  readElementText,
  readElementTextWithBehaviour,
  readNext,
  readNextStartElement,
  skipCurrentElement,
  QXmlStreamReaderConst (..),
  castQXmlStreamReaderToConst,
  QXmlStreamReader (..),
  castQXmlStreamReaderToNonconst,
  new,
  newWithPtrChar,
  newWithString,
  newWithByteArray,
  newWithIODevice,
  QXmlStreamReaderSuper (..),
  QXmlStreamReaderSuperConst (..),
  QXmlStreamReaderError (..),
  QXmlStreamReaderReadElementTextBehaviour (..),
  QXmlStreamReaderTokenType (..),
  ) where

import qualified Data.Int as HoppyDI
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QIODevice as M48
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QVector.QXmlStreamEntityDeclaration as M230
import qualified Graphics.UI.Qtah.Generated.Core.QVector.QXmlStreamNamespaceDeclaration as M232
import qualified Graphics.UI.Qtah.Generated.Core.QVector.QXmlStreamNotationDeclaration as M234
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamAttributes as M176
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamEntityResolver as M180
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamNamespaceDeclaration as M182
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QXmlStreamReader_new" new' ::  HoppyP.IO (HoppyF.Ptr QXmlStreamReader)
foreign import ccall "genpop__QXmlStreamReader_newWithPtrChar" newWithPtrChar' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QXmlStreamReader)
foreign import ccall "genpop__QXmlStreamReader_newWithString" newWithString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QXmlStreamReader)
foreign import ccall "genpop__QXmlStreamReader_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QXmlStreamReader)
foreign import ccall "genpop__QXmlStreamReader_newWithIODevice" newWithIODevice' ::  HoppyF.Ptr M48.QIODevice -> HoppyP.IO (HoppyF.Ptr QXmlStreamReader)
foreign import ccall "genpop__QXmlStreamReader_namespaceProcessing" namespaceProcessing' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_setNamespaceProcessing" setNamespaceProcessing' ::  HoppyF.Ptr QXmlStreamReader -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_addDataWithByteArray" addDataWithByteArray' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_addDataWithString" addDataWithString' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_addDataWithPtrChar" addDataWithPtrChar' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_addExtraNamespaceDeclaration" addExtraNamespaceDeclaration' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M182.QXmlStreamNamespaceDeclarationConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_addExtraNamespaceDeclarations" addExtraNamespaceDeclarations' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M232.QVectorQQXmlStreamNamespaceDeclarationConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_atEnd" atEnd' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_attributes" attributes' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M176.QXmlStreamAttributes)
foreign import ccall "genpop__QXmlStreamReader_characterOffset" characterOffset' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QXmlStreamReader_clear" clear' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_columnNumber" columnNumber' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QXmlStreamReader_device" device' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M48.QIODevice)
foreign import ccall "genpop__QXmlStreamReader_setDevice" setDevice' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M48.QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_entityDeclarations" entityDeclarations' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M230.QVectorQXmlStreamEntityDeclaration)
foreign import ccall "genpop__QXmlStreamReader_entityResolver" entityResolver' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M180.QXmlStreamEntityResolver)
foreign import ccall "genpop__QXmlStreamReader_setEntityResolver" setEntityResolver' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M180.QXmlStreamEntityResolver -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_error" error' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QXmlStreamReader_errorString" errorString' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QXmlStreamReader_hasError" hasError' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isCDATA" isCDATA' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isCharacters" isCharacters' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isComment" isComment' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isDTD" isDTD' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isEndDocument" isEndDocument' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isEndElement" isEndElement' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isEntityReference" isEntityReference' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isProcessingInstruction" isProcessingInstruction' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isStandaloneDocument" isStandaloneDocument' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isStartDocument" isStartDocument' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isStartElement" isStartElement' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_isWhitespace" isWhitespace' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_lineNumber" lineNumber' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QXmlStreamReader_namespaceDeclarations" namespaceDeclarations' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M232.QVectorQQXmlStreamNamespaceDeclaration)
foreign import ccall "genpop__QXmlStreamReader_notationDeclarations" notationDeclarations' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M234.QVectorQXmlStreamNotationDeclaration)
foreign import ccall "genpop__QXmlStreamReader_raiseError" raiseError' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_raiseErrorWithMessage" raiseErrorWithMessage' ::  HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_readElementText" readElementText' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QXmlStreamReader_readElementTextWithBehaviour" readElementTextWithBehaviour' ::  HoppyF.Ptr QXmlStreamReader -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QXmlStreamReader_readNext" readNext' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QXmlStreamReader_readNextStartElement" readNextStartElement' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamReader_skipCurrentElement" skipCurrentElement' ::  HoppyF.Ptr QXmlStreamReader -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamReader_tokenString" tokenString' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QXmlStreamReader_tokenType" tokenType' ::  HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "gendel__QXmlStreamReader" delete'QXmlStreamReader :: HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO ()
foreign import ccall "&gendel__QXmlStreamReader" deletePtr'QXmlStreamReader :: HoppyF.FunPtr (HoppyF.Ptr QXmlStreamReaderConst -> HoppyP.IO ())

class QXmlStreamReaderValue a where
  withQXmlStreamReaderPtr :: a -> (QXmlStreamReaderConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QXmlStreamReaderConstPtr a => QXmlStreamReaderValue a where
  withQXmlStreamReaderPtr = HoppyP.flip ($) . toQXmlStreamReaderConst

class (HoppyFHR.CppPtr this) => QXmlStreamReaderConstPtr this where
  toQXmlStreamReaderConst :: this -> QXmlStreamReaderConst

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

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

attributes :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M176.QXmlStreamAttributes)
attributes arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M176.QXmlStreamAttributes
  (attributes' arg'1')

characterOffset :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
characterOffset arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (characterOffset' arg'1')

columnNumber :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
columnNumber arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (columnNumber' arg'1')

device :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M48.QIODevice)
device arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M48.QIODevice
  (device' arg'1')

entityDeclarations :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M230.QVectorQXmlStreamEntityDeclaration)
entityDeclarations arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M230.QVectorQXmlStreamEntityDeclaration
  (entityDeclarations' arg'1')

entityResolver :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M180.QXmlStreamEntityResolver)
entityResolver arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M180.QXmlStreamEntityResolver
  (entityResolver' arg'1')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lineNumber :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
lineNumber arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (lineNumber' arg'1')

namespaceDeclarations :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M232.QVectorQQXmlStreamNamespaceDeclaration)
namespaceDeclarations arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M232.QVectorQQXmlStreamNamespaceDeclaration
  (namespaceDeclarations' arg'1')

notationDeclarations :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO M234.QVectorQXmlStreamNotationDeclaration)
notationDeclarations arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M234.QVectorQXmlStreamNotationDeclaration
  (notationDeclarations' arg'1')

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

tokenType :: (QXmlStreamReaderValue this) => (this) {- ^ this -} -> (HoppyP.IO QXmlStreamReaderTokenType)
tokenType arg'1 =
  withQXmlStreamReaderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (tokenType' arg'1')

class (QXmlStreamReaderConstPtr this) => QXmlStreamReaderPtr this where
  toQXmlStreamReader :: this -> QXmlStreamReader

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

addDataWithByteArray :: (QXmlStreamReaderPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addDataWithByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (addDataWithByteArray' arg'1' arg'2')

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

addDataWithPtrChar :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO ())
addDataWithPtrChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (addDataWithPtrChar' arg'1' arg'2')

addExtraNamespaceDeclaration :: (QXmlStreamReaderPtr this, M182.QXmlStreamNamespaceDeclarationValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addExtraNamespaceDeclaration arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  M182.withQXmlStreamNamespaceDeclarationPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (addExtraNamespaceDeclaration' arg'1' arg'2')

addExtraNamespaceDeclarations :: (QXmlStreamReaderPtr this, M232.QVectorQQXmlStreamNamespaceDeclarationValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addExtraNamespaceDeclarations arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  M232.withQVectorQQXmlStreamNamespaceDeclarationPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (addExtraNamespaceDeclarations' arg'1' arg'2')

clear :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (clear' arg'1')

setDevice :: (QXmlStreamReaderPtr this, M48.QIODevicePtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setDevice arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M48.toQIODevice arg'2) $ \arg'2' ->
  (setDevice' arg'1' arg'2')

setEntityResolver :: (QXmlStreamReaderPtr this, M180.QXmlStreamEntityResolverPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setEntityResolver arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M180.toQXmlStreamEntityResolver arg'2) $ \arg'2' ->
  (setEntityResolver' arg'1' arg'2')

raiseError :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
raiseError arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (raiseError' arg'1')

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

readElementText :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
readElementText arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (readElementText' arg'1')

readElementTextWithBehaviour :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (QXmlStreamReaderReadElementTextBehaviour) -> (HoppyP.IO QtahP.String)
readElementTextWithBehaviour arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (readElementTextWithBehaviour' arg'1' arg'2')

readNext :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyP.IO QXmlStreamReaderTokenType)
readNext arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (readNext' arg'1')

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

skipCurrentElement :: (QXmlStreamReaderPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
skipCurrentElement arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamReader arg'1) $ \arg'1' ->
  (skipCurrentElement' arg'1')

data QXmlStreamReaderConst =
    QXmlStreamReaderConst (HoppyF.Ptr QXmlStreamReaderConst)
  | QXmlStreamReaderConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamReaderConst)
  deriving (HoppyP.Show)

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

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

castQXmlStreamReaderToConst :: QXmlStreamReader -> QXmlStreamReaderConst
castQXmlStreamReaderToConst (QXmlStreamReader ptr') = QXmlStreamReaderConst $ HoppyF.castPtr ptr'
castQXmlStreamReaderToConst (QXmlStreamReaderGc fptr' ptr') = QXmlStreamReaderConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QXmlStreamReaderConstPtr QXmlStreamReaderConst where
  toQXmlStreamReaderConst = HoppyP.id

data QXmlStreamReader =
    QXmlStreamReader (HoppyF.Ptr QXmlStreamReader)
  | QXmlStreamReaderGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamReader)
  deriving (HoppyP.Show)

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

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

castQXmlStreamReaderToNonconst :: QXmlStreamReaderConst -> QXmlStreamReader
castQXmlStreamReaderToNonconst (QXmlStreamReaderConst ptr') = QXmlStreamReader $ HoppyF.castPtr ptr'
castQXmlStreamReaderToNonconst (QXmlStreamReaderConstGc fptr' ptr') = QXmlStreamReaderGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QXmlStreamReaderConstPtr QXmlStreamReader where
  toQXmlStreamReaderConst (QXmlStreamReader ptr') = QXmlStreamReaderConst $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr QXmlStreamReaderConst) ptr'
  toQXmlStreamReaderConst (QXmlStreamReaderGc fptr' ptr') = QXmlStreamReaderConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamReader -> HoppyF.Ptr QXmlStreamReaderConst) ptr'

instance QXmlStreamReaderPtr QXmlStreamReader where
  toQXmlStreamReader = HoppyP.id

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

newWithPtrChar :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QXmlStreamReader)
newWithPtrChar arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QXmlStreamReader
  (newWithPtrChar' arg'1')

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

newWithByteArray :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QXmlStreamReader)
newWithByteArray arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QXmlStreamReader
  (newWithByteArray' arg'1')

newWithIODevice :: (M48.QIODevicePtr arg'1) => (arg'1) -> (HoppyP.IO QXmlStreamReader)
newWithIODevice arg'1 =
  HoppyFHR.withCppPtr (M48.toQIODevice arg'1) $ \arg'1' ->
  HoppyP.fmap QXmlStreamReader
  (newWithIODevice' arg'1')

class QXmlStreamReaderSuper a where
  downToQXmlStreamReader :: a -> QXmlStreamReader


class QXmlStreamReaderSuperConst a where
  downToQXmlStreamReaderConst :: a -> QXmlStreamReaderConst


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

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

data QXmlStreamReaderError =
  NoError
  | UnexpectedElementError
  | CustomError
  | NotWellFormedError
  | PrematureEndOfDocumentError
  | UnknownQXmlStreamReaderError (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QXmlStreamReaderError where
  fromCppEnum NoError = 0
  fromCppEnum UnexpectedElementError = 1
  fromCppEnum CustomError = 2
  fromCppEnum NotWellFormedError = 3
  fromCppEnum PrematureEndOfDocumentError = 4
  fromCppEnum (UnknownQXmlStreamReaderError n) = n
  
  toCppEnum (0) = NoError
  toCppEnum (1) = UnexpectedElementError
  toCppEnum (2) = CustomError
  toCppEnum (3) = NotWellFormedError
  toCppEnum (4) = PrematureEndOfDocumentError
  toCppEnum n = UnknownQXmlStreamReaderError n

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

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

data QXmlStreamReaderReadElementTextBehaviour =
  ErrorOnUnexpectedElement
  | IncludeChildElements
  | SkipChildElements
  | UnknownQXmlStreamReaderReadElementTextBehaviour (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QXmlStreamReaderReadElementTextBehaviour where
  fromCppEnum ErrorOnUnexpectedElement = 0
  fromCppEnum IncludeChildElements = 1
  fromCppEnum SkipChildElements = 2
  fromCppEnum (UnknownQXmlStreamReaderReadElementTextBehaviour n) = n
  
  toCppEnum (0) = ErrorOnUnexpectedElement
  toCppEnum (1) = IncludeChildElements
  toCppEnum (2) = SkipChildElements
  toCppEnum n = UnknownQXmlStreamReaderReadElementTextBehaviour n

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

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

data QXmlStreamReaderTokenType =
  NoToken
  | Invalid
  | StartDocument
  | EndDocument
  | StartElement
  | EndElement
  | Characters
  | Comment
  | Dtd
  | EntityReference
  | ProcessingInstruction
  | UnknownQXmlStreamReaderTokenType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QXmlStreamReaderTokenType where
  fromCppEnum NoToken = 0
  fromCppEnum Invalid = 1
  fromCppEnum StartDocument = 2
  fromCppEnum EndDocument = 3
  fromCppEnum StartElement = 4
  fromCppEnum EndElement = 5
  fromCppEnum Characters = 6
  fromCppEnum Comment = 7
  fromCppEnum Dtd = 8
  fromCppEnum EntityReference = 9
  fromCppEnum ProcessingInstruction = 10
  fromCppEnum (UnknownQXmlStreamReaderTokenType n) = n
  
  toCppEnum (0) = NoToken
  toCppEnum (1) = Invalid
  toCppEnum (2) = StartDocument
  toCppEnum (3) = EndDocument
  toCppEnum (4) = StartElement
  toCppEnum (5) = EndElement
  toCppEnum (6) = Characters
  toCppEnum (7) = Comment
  toCppEnum (8) = Dtd
  toCppEnum (9) = EntityReference
  toCppEnum (10) = ProcessingInstruction
  toCppEnum n = UnknownQXmlStreamReaderTokenType n

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

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