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

module Graphics.UI.Qtah.Generated.Core.QMetaClassInfo (
  QMetaClassInfoValue (..),
  QMetaClassInfoConstPtr (..),
  name,
  value,
  QMetaClassInfoPtr (..),
  QMetaClassInfoConst (..),
  castQMetaClassInfoToConst,
  QMetaClassInfo (..),
  castQMetaClassInfoToNonconst,
  newCopy,
  QMetaClassInfoSuper (..),
  QMetaClassInfoSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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__QMetaClassInfo_newCopy" newCopy' ::  HoppyF.Ptr QMetaClassInfoConst -> HoppyP.IO (HoppyF.Ptr QMetaClassInfo)
foreign import ccall "genpop__QMetaClassInfo_name" name' ::  HoppyF.Ptr QMetaClassInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMetaClassInfo_value" value' ::  HoppyF.Ptr QMetaClassInfoConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gendel__QMetaClassInfo" delete'QMetaClassInfo :: HoppyF.Ptr QMetaClassInfoConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMetaClassInfo" deletePtr'QMetaClassInfo :: HoppyF.FunPtr (HoppyF.Ptr QMetaClassInfoConst -> HoppyP.IO ())

class QMetaClassInfoValue a where
  withQMetaClassInfoPtr :: a -> (QMetaClassInfoConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMetaClassInfoConstPtr a => QMetaClassInfoValue a where
  withQMetaClassInfoPtr = HoppyP.flip ($) . toQMetaClassInfoConst

class (HoppyFHR.CppPtr this) => QMetaClassInfoConstPtr this where
  toQMetaClassInfoConst :: this -> QMetaClassInfoConst

name :: (QMetaClassInfoValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
name arg'1 =
  withQMetaClassInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (name' arg'1')

value :: (QMetaClassInfoValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
value arg'1 =
  withQMetaClassInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (value' arg'1')

class (QMetaClassInfoConstPtr this) => QMetaClassInfoPtr this where
  toQMetaClassInfo :: this -> QMetaClassInfo

data QMetaClassInfoConst =
    QMetaClassInfoConst (HoppyF.Ptr QMetaClassInfoConst)
  | QMetaClassInfoConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaClassInfoConst)
  deriving (HoppyP.Show)

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

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

castQMetaClassInfoToConst :: QMetaClassInfo -> QMetaClassInfoConst
castQMetaClassInfoToConst (QMetaClassInfo ptr') = QMetaClassInfoConst $ HoppyF.castPtr ptr'
castQMetaClassInfoToConst (QMetaClassInfoGc fptr' ptr') = QMetaClassInfoConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaClassInfoConst QMetaClassInfo where copy = newCopy

instance QMetaClassInfoConstPtr QMetaClassInfoConst where
  toQMetaClassInfoConst = HoppyP.id

data QMetaClassInfo =
    QMetaClassInfo (HoppyF.Ptr QMetaClassInfo)
  | QMetaClassInfoGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaClassInfo)
  deriving (HoppyP.Show)

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

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

castQMetaClassInfoToNonconst :: QMetaClassInfoConst -> QMetaClassInfo
castQMetaClassInfoToNonconst (QMetaClassInfoConst ptr') = QMetaClassInfo $ HoppyF.castPtr ptr'
castQMetaClassInfoToNonconst (QMetaClassInfoConstGc fptr' ptr') = QMetaClassInfoGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaClassInfo QMetaClassInfo where copy = newCopy

instance QMetaClassInfoConstPtr QMetaClassInfo where
  toQMetaClassInfoConst (QMetaClassInfo ptr') = QMetaClassInfoConst $ (HoppyF.castPtr :: HoppyF.Ptr QMetaClassInfo -> HoppyF.Ptr QMetaClassInfoConst) ptr'
  toQMetaClassInfoConst (QMetaClassInfoGc fptr' ptr') = QMetaClassInfoConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMetaClassInfo -> HoppyF.Ptr QMetaClassInfoConst) ptr'

instance QMetaClassInfoPtr QMetaClassInfo where
  toQMetaClassInfo = HoppyP.id

newCopy :: (QMetaClassInfoValue arg'1) => (arg'1) -> (HoppyP.IO QMetaClassInfo)
newCopy arg'1 =
  withQMetaClassInfoPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QMetaClassInfo
  (newCopy' arg'1')

class QMetaClassInfoSuper a where
  downToQMetaClassInfo :: a -> QMetaClassInfo


class QMetaClassInfoSuperConst a where
  downToQMetaClassInfoConst :: a -> QMetaClassInfoConst


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

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

instance HoppyFHR.Decodable QMetaClassInfo (QMetaClassInfo) where
  decode = HoppyFHR.decode . toQMetaClassInfoConst

instance HoppyFHR.Decodable QMetaClassInfoConst (QMetaClassInfo) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc