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

module Graphics.UI.Qtah.Generated.Core.QXmlStreamNamespaceDeclaration (
  QXmlStreamNamespaceDeclarationValue (..),
  QXmlStreamNamespaceDeclarationConstPtr (..),
  eQ,
  nE,
  QXmlStreamNamespaceDeclarationPtr (..),
  aSSIGN,
  QXmlStreamNamespaceDeclarationConst (..),
  castQXmlStreamNamespaceDeclarationToConst,
  QXmlStreamNamespaceDeclaration (..),
  castQXmlStreamNamespaceDeclarationToNonconst,
  new,
  newWithPrefixAndNamespaceUri,
  newCopy,
  QXmlStreamNamespaceDeclarationSuper (..),
  QXmlStreamNamespaceDeclarationSuperConst (..),
  ) where

import Control.Monad ((>=>))
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.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_new" new' ::  HoppyP.IO (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_newWithPrefixAndNamespaceUri" newWithPrefixAndNamespaceUri' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_newCopy" newCopy' ::  HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_EQ" eQ' ::  HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_NE" nE' ::  HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QXmlStreamNamespaceDeclaration_ASSIGN" aSSIGN' ::  HoppyF.Ptr QXmlStreamNamespaceDeclaration -> HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
foreign import ccall "gendel__QXmlStreamNamespaceDeclaration" delete'QXmlStreamNamespaceDeclaration :: HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO ()
foreign import ccall "&gendel__QXmlStreamNamespaceDeclaration" deletePtr'QXmlStreamNamespaceDeclaration :: HoppyF.FunPtr (HoppyF.Ptr QXmlStreamNamespaceDeclarationConst -> HoppyP.IO ())

class QXmlStreamNamespaceDeclarationValue a where
  withQXmlStreamNamespaceDeclarationPtr :: a -> (QXmlStreamNamespaceDeclarationConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QXmlStreamNamespaceDeclarationConstPtr a => QXmlStreamNamespaceDeclarationValue a where
  withQXmlStreamNamespaceDeclarationPtr = HoppyP.flip ($) . toQXmlStreamNamespaceDeclarationConst

class (HoppyFHR.CppPtr this) => QXmlStreamNamespaceDeclarationConstPtr this where
  toQXmlStreamNamespaceDeclarationConst :: this -> QXmlStreamNamespaceDeclarationConst

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

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

class (QXmlStreamNamespaceDeclarationConstPtr this) => QXmlStreamNamespaceDeclarationPtr this where
  toQXmlStreamNamespaceDeclaration :: this -> QXmlStreamNamespaceDeclaration

aSSIGN :: (QXmlStreamNamespaceDeclarationPtr this, QXmlStreamNamespaceDeclarationValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QXmlStreamNamespaceDeclaration)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQXmlStreamNamespaceDeclaration arg'1) $ \arg'1' ->
  withQXmlStreamNamespaceDeclarationPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QXmlStreamNamespaceDeclaration
  (aSSIGN' arg'1' arg'2')

data QXmlStreamNamespaceDeclarationConst =
    QXmlStreamNamespaceDeclarationConst (HoppyF.Ptr QXmlStreamNamespaceDeclarationConst)
  | QXmlStreamNamespaceDeclarationConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamNamespaceDeclarationConst)
  deriving (HoppyP.Show)

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

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

castQXmlStreamNamespaceDeclarationToConst :: QXmlStreamNamespaceDeclaration -> QXmlStreamNamespaceDeclarationConst
castQXmlStreamNamespaceDeclarationToConst (QXmlStreamNamespaceDeclaration ptr') = QXmlStreamNamespaceDeclarationConst $ HoppyF.castPtr ptr'
castQXmlStreamNamespaceDeclarationToConst (QXmlStreamNamespaceDeclarationGc fptr' ptr') = QXmlStreamNamespaceDeclarationConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QXmlStreamNamespaceDeclarationConst QXmlStreamNamespaceDeclaration where copy = newCopy

instance QXmlStreamNamespaceDeclarationConstPtr QXmlStreamNamespaceDeclarationConst where
  toQXmlStreamNamespaceDeclarationConst = HoppyP.id

data QXmlStreamNamespaceDeclaration =
    QXmlStreamNamespaceDeclaration (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
  | QXmlStreamNamespaceDeclarationGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QXmlStreamNamespaceDeclaration)
  deriving (HoppyP.Show)

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

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

castQXmlStreamNamespaceDeclarationToNonconst :: QXmlStreamNamespaceDeclarationConst -> QXmlStreamNamespaceDeclaration
castQXmlStreamNamespaceDeclarationToNonconst (QXmlStreamNamespaceDeclarationConst ptr') = QXmlStreamNamespaceDeclaration $ HoppyF.castPtr ptr'
castQXmlStreamNamespaceDeclarationToNonconst (QXmlStreamNamespaceDeclarationConstGc fptr' ptr') = QXmlStreamNamespaceDeclarationGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QXmlStreamNamespaceDeclaration QXmlStreamNamespaceDeclaration where copy = newCopy

instance QXmlStreamNamespaceDeclarationConstPtr QXmlStreamNamespaceDeclaration where
  toQXmlStreamNamespaceDeclarationConst (QXmlStreamNamespaceDeclaration ptr') = QXmlStreamNamespaceDeclarationConst $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamNamespaceDeclaration -> HoppyF.Ptr QXmlStreamNamespaceDeclarationConst) ptr'
  toQXmlStreamNamespaceDeclarationConst (QXmlStreamNamespaceDeclarationGc fptr' ptr') = QXmlStreamNamespaceDeclarationConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QXmlStreamNamespaceDeclaration -> HoppyF.Ptr QXmlStreamNamespaceDeclarationConst) ptr'

instance QXmlStreamNamespaceDeclarationPtr QXmlStreamNamespaceDeclaration where
  toQXmlStreamNamespaceDeclaration = HoppyP.id

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

newWithPrefixAndNamespaceUri :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QXmlStreamNamespaceDeclaration)
newWithPrefixAndNamespaceUri arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QXmlStreamNamespaceDeclaration
  (newWithPrefixAndNamespaceUri' arg'1' arg'2')

newCopy :: (QXmlStreamNamespaceDeclarationValue arg'1) => (arg'1) -> (HoppyP.IO QXmlStreamNamespaceDeclaration)
newCopy arg'1 =
  withQXmlStreamNamespaceDeclarationPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QXmlStreamNamespaceDeclaration
  (newCopy' arg'1')

class QXmlStreamNamespaceDeclarationSuper a where
  downToQXmlStreamNamespaceDeclaration :: a -> QXmlStreamNamespaceDeclaration


class QXmlStreamNamespaceDeclarationSuperConst a where
  downToQXmlStreamNamespaceDeclarationConst :: a -> QXmlStreamNamespaceDeclarationConst


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

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

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

instance HoppyFHR.Decodable QXmlStreamNamespaceDeclaration (QXmlStreamNamespaceDeclaration) where
  decode = HoppyFHR.decode . toQXmlStreamNamespaceDeclarationConst

instance HoppyFHR.Decodable QXmlStreamNamespaceDeclarationConst (QXmlStreamNamespaceDeclaration) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc