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

module Graphics.UI.Qtah.Generated.Core.QXmlStreamWriter (
  QXmlStreamWriterValue (..),
  QXmlStreamWriterConstPtr (..),
  autoFormatting,
  autoFormattingIndent,
  codec,
  device,
  hasError,
  QXmlStreamWriterPtr (..),
  setAutoFormatting,
  setAutoFormattingIndent,
  setDevice,
  setCodec,
  setCodecWithPtrChar,
  writeAttributeWithNamespaceUriAndNameAndValue,
  writeAttributeWithQualifiedNameAndValue,
  writeAttribute,
  writeAttributes,
  writeCDATA,
  writeCharacters,
  writeComment,
  writeCurrentToken,
  writeDTD,
  writeDefaultNamespace,
  writeEmptyElementWithNamespaceUriAndName,
  writeEmptyElement,
  writeEndDocument,
  writeEndElement,
  writeEntityReference,
  writeNamespace,
  writeNamespaceWithNamespaceUriAndPrefix,
  writeProcessingInstruction,
  writeProcessingInstructionWithTargetAndData,
  writeStartDocumentWithVersion,
  writeStartDocument,
  writeStartDocumentWithVersionAndStandalone,
  writeStartElementWithNamespaceUriAndName,
  writeStartElement,
  writeTextElementWithNamespaceUriAndNameAndText,
  writeTextElementWithQualifiedNameAndText,
  QXmlStreamWriterConst (..),
  castQXmlStreamWriterToConst,
  QXmlStreamWriter (..),
  castQXmlStreamWriterToNonconst,
  new,
  newWithString,
  newWithByteArray,
  newWithIODevice,
  QXmlStreamWriterSuper (..),
  QXmlStreamWriterSuperConst (..),
  ) where

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.QTextCodec as M150
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamAttribute as M174
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamAttributes as M176
import qualified Graphics.UI.Qtah.Generated.Core.QXmlStreamReader as M186
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QXmlStreamWriter_new" new' ::  HoppyP.IO (HoppyF.Ptr QXmlStreamWriter)
foreign import ccall "genpop__QXmlStreamWriter_newWithString" newWithString' ::  HoppyF.Ptr M142.QString -> HoppyP.IO (HoppyF.Ptr QXmlStreamWriter)
foreign import ccall "genpop__QXmlStreamWriter_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArray -> HoppyP.IO (HoppyF.Ptr QXmlStreamWriter)
foreign import ccall "genpop__QXmlStreamWriter_newWithIODevice" newWithIODevice' ::  HoppyF.Ptr M48.QIODevice -> HoppyP.IO (HoppyF.Ptr QXmlStreamWriter)
foreign import ccall "genpop__QXmlStreamWriter_autoFormatting" autoFormatting' ::  HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamWriter_setAutoFormatting" setAutoFormatting' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_autoFormattingIndent" autoFormattingIndent' ::  HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QXmlStreamWriter_setAutoFormattingIndent" setAutoFormattingIndent' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_codec" codec' ::  HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO (HoppyF.Ptr M150.QTextCodec)
foreign import ccall "genpop__QXmlStreamWriter_device" device' ::  HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO (HoppyF.Ptr M48.QIODevice)
foreign import ccall "genpop__QXmlStreamWriter_setDevice" setDevice' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M48.QIODevice -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_hasError" hasError' ::  HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamWriter_setCodec" setCodec' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M150.QTextCodec -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_setCodecWithPtrChar" setCodecWithPtrChar' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeAttributeWithNamespaceUriAndNameAndValue" writeAttributeWithNamespaceUriAndNameAndValue' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeAttributeWithQualifiedNameAndValue" writeAttributeWithQualifiedNameAndValue' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeAttribute" writeAttribute' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M174.QXmlStreamAttributeConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeAttributes" writeAttributes' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M176.QXmlStreamAttributesConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeCDATA" writeCDATA' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeCharacters" writeCharacters' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeComment" writeComment' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeCurrentToken" writeCurrentToken' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M186.QXmlStreamReaderConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeDTD" writeDTD' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeDefaultNamespace" writeDefaultNamespace' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeEmptyElementWithNamespaceUriAndName" writeEmptyElementWithNamespaceUriAndName' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeEmptyElement" writeEmptyElement' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeEndDocument" writeEndDocument' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeEndElement" writeEndElement' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeEntityReference" writeEntityReference' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeNamespace" writeNamespace' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeNamespaceWithNamespaceUriAndPrefix" writeNamespaceWithNamespaceUriAndPrefix' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeProcessingInstruction" writeProcessingInstruction' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeProcessingInstructionWithTargetAndData" writeProcessingInstructionWithTargetAndData' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeStartDocumentWithVersion" writeStartDocumentWithVersion' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeStartDocument" writeStartDocument' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeStartDocumentWithVersionAndStandalone" writeStartDocumentWithVersionAndStandalone' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeStartElementWithNamespaceUriAndName" writeStartElementWithNamespaceUriAndName' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeStartElement" writeStartElement' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeTextElementWithNamespaceUriAndNameAndText" writeTextElementWithNamespaceUriAndNameAndText' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QXmlStreamWriter_writeTextElementWithQualifiedNameAndText" writeTextElementWithQualifiedNameAndText' ::  HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gendel__QXmlStreamWriter" delete'QXmlStreamWriter :: HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO ()
foreign import ccall "&gendel__QXmlStreamWriter" deletePtr'QXmlStreamWriter :: HoppyF.FunPtr (HoppyF.Ptr QXmlStreamWriterConst -> HoppyP.IO ())

class QXmlStreamWriterValue a where
  withQXmlStreamWriterPtr :: a -> (QXmlStreamWriterConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QXmlStreamWriterConstPtr a => QXmlStreamWriterValue a where
  withQXmlStreamWriterPtr = HoppyP.flip ($) . toQXmlStreamWriterConst

class (HoppyFHR.CppPtr this) => QXmlStreamWriterConstPtr this where
  toQXmlStreamWriterConst :: this -> QXmlStreamWriterConst

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

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

codec :: (QXmlStreamWriterValue this) => (this) {- ^ this -} -> (HoppyP.IO M150.QTextCodec)
codec arg'1 =
  withQXmlStreamWriterPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M150.QTextCodec
  (codec' arg'1')

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

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

class (QXmlStreamWriterConstPtr this) => QXmlStreamWriterPtr this where
  toQXmlStreamWriter :: this -> QXmlStreamWriter

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

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

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

setCodec :: (QXmlStreamWriterPtr this, M150.QTextCodecPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setCodec arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M150.toQTextCodec arg'2) $ \arg'2' ->
  (setCodec' arg'1' arg'2')

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

writeAttributeWithNamespaceUriAndNameAndValue :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
writeAttributeWithNamespaceUriAndNameAndValue arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (writeAttributeWithNamespaceUriAndNameAndValue' arg'1' arg'2' arg'3' arg'4')

writeAttributeWithQualifiedNameAndValue :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeAttributeWithQualifiedNameAndValue arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeAttributeWithQualifiedNameAndValue' arg'1' arg'2' arg'3')

writeAttribute :: (QXmlStreamWriterPtr this, M174.QXmlStreamAttributeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
writeAttribute arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M174.withQXmlStreamAttributePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (writeAttribute' arg'1' arg'2')

writeAttributes :: (QXmlStreamWriterPtr this, M176.QXmlStreamAttributesValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
writeAttributes arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M176.withQXmlStreamAttributesPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (writeAttributes' arg'1' arg'2')

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

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

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

writeCurrentToken :: (QXmlStreamWriterPtr this, M186.QXmlStreamReaderValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
writeCurrentToken arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M186.withQXmlStreamReaderPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (writeCurrentToken' arg'1' arg'2')

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

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

writeEmptyElementWithNamespaceUriAndName :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeEmptyElementWithNamespaceUriAndName arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeEmptyElementWithNamespaceUriAndName' arg'1' arg'2' arg'3')

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

writeEndDocument :: (QXmlStreamWriterPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
writeEndDocument arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  (writeEndDocument' arg'1')

writeEndElement :: (QXmlStreamWriterPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
writeEndElement arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  (writeEndElement' arg'1')

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

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

writeNamespaceWithNamespaceUriAndPrefix :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeNamespaceWithNamespaceUriAndPrefix arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeNamespaceWithNamespaceUriAndPrefix' arg'1' arg'2' arg'3')

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

writeProcessingInstructionWithTargetAndData :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeProcessingInstructionWithTargetAndData arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeProcessingInstructionWithTargetAndData' arg'1' arg'2' arg'3')

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

writeStartDocument :: (QXmlStreamWriterPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
writeStartDocument arg'1 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  (writeStartDocument' arg'1')

writeStartDocumentWithVersionAndStandalone :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Bool) -> (HoppyP.IO ())
writeStartDocumentWithVersionAndStandalone arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (writeStartDocumentWithVersionAndStandalone' arg'1' arg'2' arg'3')

writeStartElementWithNamespaceUriAndName :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeStartElementWithNamespaceUriAndName arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeStartElementWithNamespaceUriAndName' arg'1' arg'2' arg'3')

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

writeTextElementWithNamespaceUriAndNameAndText :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
writeTextElementWithNamespaceUriAndNameAndText arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (writeTextElementWithNamespaceUriAndNameAndText' arg'1' arg'2' arg'3' arg'4')

writeTextElementWithQualifiedNameAndText :: (QXmlStreamWriterPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
writeTextElementWithQualifiedNameAndText arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQXmlStreamWriter arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (writeTextElementWithQualifiedNameAndText' arg'1' arg'2' arg'3')

data QXmlStreamWriterConst =
    QXmlStreamWriterConst (HoppyF.Ptr QXmlStreamWriterConst)
  | QXmlStreamWriterConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamWriterConst)
  deriving (HoppyP.Show)

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

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

castQXmlStreamWriterToConst :: QXmlStreamWriter -> QXmlStreamWriterConst
castQXmlStreamWriterToConst (QXmlStreamWriter ptr') = QXmlStreamWriterConst $ HoppyF.castPtr ptr'
castQXmlStreamWriterToConst (QXmlStreamWriterGc fptr' ptr') = QXmlStreamWriterConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QXmlStreamWriterConstPtr QXmlStreamWriterConst where
  toQXmlStreamWriterConst = HoppyP.id

data QXmlStreamWriter =
    QXmlStreamWriter (HoppyF.Ptr QXmlStreamWriter)
  | QXmlStreamWriterGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamWriter)
  deriving (HoppyP.Show)

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

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

castQXmlStreamWriterToNonconst :: QXmlStreamWriterConst -> QXmlStreamWriter
castQXmlStreamWriterToNonconst (QXmlStreamWriterConst ptr') = QXmlStreamWriter $ HoppyF.castPtr ptr'
castQXmlStreamWriterToNonconst (QXmlStreamWriterConstGc fptr' ptr') = QXmlStreamWriterGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QXmlStreamWriterConstPtr QXmlStreamWriter where
  toQXmlStreamWriterConst (QXmlStreamWriter ptr') = QXmlStreamWriterConst $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr QXmlStreamWriterConst) ptr'
  toQXmlStreamWriterConst (QXmlStreamWriterGc fptr' ptr') = QXmlStreamWriterConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamWriter -> HoppyF.Ptr QXmlStreamWriterConst) ptr'

instance QXmlStreamWriterPtr QXmlStreamWriter where
  toQXmlStreamWriter = HoppyP.id

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

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

newWithByteArray :: (M12.QByteArrayPtr arg'1) => (arg'1) -> (HoppyP.IO QXmlStreamWriter)
newWithByteArray arg'1 =
  HoppyFHR.withCppPtr (M12.toQByteArray arg'1) $ \arg'1' ->
  HoppyP.fmap QXmlStreamWriter
  (newWithByteArray' arg'1')

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

class QXmlStreamWriterSuper a where
  downToQXmlStreamWriter :: a -> QXmlStreamWriter


class QXmlStreamWriterSuperConst a where
  downToQXmlStreamWriterConst :: a -> QXmlStreamWriterConst


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

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