QMetaObject.hs

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

module Graphics.UI.Qtah.Generated.Core.QMetaObject (
  QMetaObjectValue (..),
  QMetaObjectConstPtr (..),
  classInfo,
  classInfoCount,
  classInfoOffset,
  constructor,
  constructorCount,
  enumerator,
  enumeratorCount,
  enumeratorOffset,
  indexOfClassInfo,
  indexOfConstructor,
  indexOfEnumerator,
  indexOfMethod,
  indexOfProperty,
  indexOfSignal,
  indexOfSlot,
  inherits,
  method,
  methodCount,
  methodOffset,
  property,
  propertyCount,
  propertyOffset,
  superClass,
  userProperty,
  QMetaObjectPtr (..),
  QMetaObjectConst (..),
  castQMetaObjectToConst,
  QMetaObject (..),
  castQMetaObjectToNonconst,
  QMetaObjectSuper (..),
  QMetaObjectSuperConst (..),
  ) 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.QMetaClassInfo as M78
import qualified Graphics.UI.Qtah.Generated.Core.QMetaEnum as M80
import qualified Graphics.UI.Qtah.Generated.Core.QMetaMethod as M82
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QMetaProperty as M88
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QMetaObject_classInfo" classInfo' ::  HoppyF.Ptr QMetaObjectConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M78.QMetaClassInfoConst)
foreign import ccall "genpop__QMetaObject_classInfoCount" classInfoCount' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_classInfoOffset" classInfoOffset' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_constructor" constructor' ::  HoppyF.Ptr QMetaObjectConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M82.QMetaMethodConst)
foreign import ccall "genpop__QMetaObject_constructorCount" constructorCount' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_enumerator" enumerator' ::  HoppyF.Ptr QMetaObjectConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M80.QMetaEnumConst)
foreign import ccall "genpop__QMetaObject_enumeratorCount" enumeratorCount' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_enumeratorOffset" enumeratorOffset' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfClassInfo" indexOfClassInfo' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfConstructor" indexOfConstructor' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfEnumerator" indexOfEnumerator' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfMethod" indexOfMethod' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfProperty" indexOfProperty' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfSignal" indexOfSignal' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_indexOfSlot" indexOfSlot' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_inherits" inherits' ::  HoppyF.Ptr QMetaObjectConst -> HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaObject_method" method' ::  HoppyF.Ptr QMetaObjectConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M82.QMetaMethodConst)
foreign import ccall "genpop__QMetaObject_methodCount" methodCount' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_methodOffset" methodOffset' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_property" property' ::  HoppyF.Ptr QMetaObjectConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M88.QMetaPropertyConst)
foreign import ccall "genpop__QMetaObject_propertyCount" propertyCount' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_propertyOffset" propertyOffset' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaObject_superClass" superClass' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO (HoppyF.Ptr QMetaObjectConst)
foreign import ccall "genpop__QMetaObject_userProperty" userProperty' ::  HoppyF.Ptr QMetaObjectConst -> HoppyP.IO (HoppyF.Ptr M88.QMetaPropertyConst)
foreign import ccall "gendel__QMetaObject" delete'QMetaObject :: HoppyF.Ptr QMetaObjectConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMetaObject" deletePtr'QMetaObject :: HoppyF.FunPtr (HoppyF.Ptr QMetaObjectConst -> HoppyP.IO ())

class QMetaObjectValue a where
  withQMetaObjectPtr :: a -> (QMetaObjectConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMetaObjectConstPtr a => QMetaObjectValue a where
  withQMetaObjectPtr = HoppyP.flip ($) . toQMetaObjectConst

class (HoppyFHR.CppPtr this) => QMetaObjectConstPtr this where
  toQMetaObjectConst :: this -> QMetaObjectConst

classInfo :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M78.QMetaClassInfo)
classInfo arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M78.QMetaClassInfoConst) =<<
  (classInfo' arg'1' arg'2')

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

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

constructor :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M82.QMetaMethod)
constructor arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M82.QMetaMethodConst) =<<
  (constructor' arg'1' arg'2')

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

enumerator :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M80.QMetaEnum)
enumerator arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M80.QMetaEnumConst) =<<
  (enumerator' arg'1' arg'2')

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

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

indexOfClassInfo :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfClassInfo arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfClassInfo' arg'1' arg'2')

indexOfConstructor :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfConstructor arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfConstructor' arg'1' arg'2')

indexOfEnumerator :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfEnumerator arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfEnumerator' arg'1' arg'2')

indexOfMethod :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfMethod arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfMethod' arg'1' arg'2')

indexOfProperty :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfProperty arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfProperty' arg'1' arg'2')

indexOfSignal :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfSignal arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfSignal' arg'1' arg'2')

indexOfSlot :: (QMetaObjectValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfSlot arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfSlot' arg'1' arg'2')

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

method :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M82.QMetaMethod)
method arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M82.QMetaMethodConst) =<<
  (method' arg'1' arg'2')

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

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

property :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M88.QMetaProperty)
property arg'1 arg'2 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M88.QMetaPropertyConst) =<<
  (property' arg'1' arg'2')

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

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

superClass :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.IO QMetaObjectConst)
superClass arg'1 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QMetaObjectConst
  (superClass' arg'1')

userProperty :: (QMetaObjectValue this) => (this) {- ^ this -} -> (HoppyP.IO M88.QMetaProperty)
userProperty arg'1 =
  withQMetaObjectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M88.QMetaPropertyConst) =<<
  (userProperty' arg'1')

class (QMetaObjectConstPtr this) => QMetaObjectPtr this where
  toQMetaObject :: this -> QMetaObject

data QMetaObjectConst =
    QMetaObjectConst (HoppyF.Ptr QMetaObjectConst)
  | QMetaObjectConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaObjectConst)
  deriving (HoppyP.Show)

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

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

castQMetaObjectToConst :: QMetaObject -> QMetaObjectConst
castQMetaObjectToConst (QMetaObject ptr') = QMetaObjectConst $ HoppyF.castPtr ptr'
castQMetaObjectToConst (QMetaObjectGc fptr' ptr') = QMetaObjectConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMetaObjectConstPtr QMetaObjectConst where
  toQMetaObjectConst = HoppyP.id

data QMetaObject =
    QMetaObject (HoppyF.Ptr QMetaObject)
  | QMetaObjectGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaObject)
  deriving (HoppyP.Show)

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

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

castQMetaObjectToNonconst :: QMetaObjectConst -> QMetaObject
castQMetaObjectToNonconst (QMetaObjectConst ptr') = QMetaObject $ HoppyF.castPtr ptr'
castQMetaObjectToNonconst (QMetaObjectConstGc fptr' ptr') = QMetaObjectGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMetaObjectConstPtr QMetaObject where
  toQMetaObjectConst (QMetaObject ptr') = QMetaObjectConst $ (HoppyF.castPtr :: HoppyF.Ptr QMetaObject -> HoppyF.Ptr QMetaObjectConst) ptr'
  toQMetaObjectConst (QMetaObjectGc fptr' ptr') = QMetaObjectConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMetaObject -> HoppyF.Ptr QMetaObjectConst) ptr'

instance QMetaObjectPtr QMetaObject where
  toQMetaObject = HoppyP.id

class QMetaObjectSuper a where
  downToQMetaObject :: a -> QMetaObject


class QMetaObjectSuperConst a where
  downToQMetaObjectConst :: a -> QMetaObjectConst


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

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