QMetaMethod.hs

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

module Graphics.UI.Qtah.Generated.Core.QMetaMethod (
  QMetaMethodValue (..),
  QMetaMethodConstPtr (..),
  access,
  isValid,
  methodIndex,
  methodSignature,
  methodType,
  name,
  parameterCount,
  parameterNames,
  parameterType,
  parameterTypes,
  returnType,
  revision,
  tag,
  typeName,
  QMetaMethodPtr (..),
  nE,
  eQ,
  QMetaMethodConst (..),
  castQMetaMethodToConst,
  QMetaMethod (..),
  castQMetaMethodToNonconst,
  newCopy,
  QMetaMethodSuper (..),
  QMetaMethodSuperConst (..),
  QMetaMethodAccess (..),
  QMetaMethodMethodType (..),
  ) where

import Control.Monad ((>=>))
import qualified Data.ByteString as QtahDBS
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.QList.QByteArray as M196
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QMetaMethod_newCopy" newCopy' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr QMetaMethod)
foreign import ccall "genpop__QMetaMethod_access" access' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_isValid" isValid' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaMethod_methodIndex" methodIndex' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_methodSignature" methodSignature' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QMetaMethod_methodType" methodType' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_name" name' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QMetaMethod_parameterCount" parameterCount' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_parameterNames" parameterNames' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QMetaMethod_parameterType" parameterType' ::  HoppyF.Ptr QMetaMethodConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_parameterTypes" parameterTypes' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QMetaMethod_returnType" returnType' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_revision" revision' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaMethod_tag" tag' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaMethod_typeName" typeName' ::  HoppyF.Ptr QMetaMethodConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaMethod_NE" nE' ::  HoppyF.Ptr QMetaMethod -> HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaMethod_EQ" eQ' ::  HoppyF.Ptr QMetaMethod -> HoppyF.Ptr QMetaMethodConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QMetaMethod" delete'QMetaMethod :: HoppyF.Ptr QMetaMethodConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMetaMethod" deletePtr'QMetaMethod :: HoppyF.FunPtr (HoppyF.Ptr QMetaMethodConst -> HoppyP.IO ())

class QMetaMethodValue a where
  withQMetaMethodPtr :: a -> (QMetaMethodConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMetaMethodConstPtr a => QMetaMethodValue a where
  withQMetaMethodPtr = HoppyP.flip ($) . toQMetaMethodConst

class (HoppyFHR.CppPtr this) => QMetaMethodConstPtr this where
  toQMetaMethodConst :: this -> QMetaMethodConst

access :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO QMetaMethodAccess)
access arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (access' arg'1')

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

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

methodSignature :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
methodSignature arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (methodSignature' arg'1')

methodType :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO QMetaMethodMethodType)
methodType arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (methodType' arg'1')

name :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
name arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (name' arg'1')

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

parameterNames :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahDBS.ByteString])
parameterNames arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (parameterNames' arg'1')

parameterType :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
parameterType arg'1 arg'2 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (parameterType' arg'1' arg'2')

parameterTypes :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahDBS.ByteString])
parameterTypes arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (parameterTypes' arg'1')

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

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

tag :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
tag arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (tag' arg'1')

typeName :: (QMetaMethodValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
typeName arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (typeName' arg'1')

class (QMetaMethodConstPtr this) => QMetaMethodPtr this where
  toQMetaMethod :: this -> QMetaMethod

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

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

data QMetaMethodConst =
    QMetaMethodConst (HoppyF.Ptr QMetaMethodConst)
  | QMetaMethodConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaMethodConst)
  deriving (HoppyP.Show)

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

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

castQMetaMethodToConst :: QMetaMethod -> QMetaMethodConst
castQMetaMethodToConst (QMetaMethod ptr') = QMetaMethodConst $ HoppyF.castPtr ptr'
castQMetaMethodToConst (QMetaMethodGc fptr' ptr') = QMetaMethodConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaMethodConst QMetaMethod where copy = newCopy

instance QMetaMethodConstPtr QMetaMethodConst where
  toQMetaMethodConst = HoppyP.id

data QMetaMethod =
    QMetaMethod (HoppyF.Ptr QMetaMethod)
  | QMetaMethodGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaMethod)
  deriving (HoppyP.Show)

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

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

castQMetaMethodToNonconst :: QMetaMethodConst -> QMetaMethod
castQMetaMethodToNonconst (QMetaMethodConst ptr') = QMetaMethod $ HoppyF.castPtr ptr'
castQMetaMethodToNonconst (QMetaMethodConstGc fptr' ptr') = QMetaMethodGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaMethod QMetaMethod where copy = newCopy

instance QMetaMethodConstPtr QMetaMethod where
  toQMetaMethodConst (QMetaMethod ptr') = QMetaMethodConst $ (HoppyF.castPtr :: HoppyF.Ptr QMetaMethod -> HoppyF.Ptr QMetaMethodConst) ptr'
  toQMetaMethodConst (QMetaMethodGc fptr' ptr') = QMetaMethodConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMetaMethod -> HoppyF.Ptr QMetaMethodConst) ptr'

instance QMetaMethodPtr QMetaMethod where
  toQMetaMethod = HoppyP.id

newCopy :: (QMetaMethodValue arg'1) => (arg'1) -> (HoppyP.IO QMetaMethod)
newCopy arg'1 =
  withQMetaMethodPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QMetaMethod
  (newCopy' arg'1')

class QMetaMethodSuper a where
  downToQMetaMethod :: a -> QMetaMethod


class QMetaMethodSuperConst a where
  downToQMetaMethodConst :: a -> QMetaMethodConst


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

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

instance HoppyFHR.Decodable QMetaMethod (QMetaMethod) where
  decode = HoppyFHR.decode . toQMetaMethodConst

instance HoppyFHR.Decodable QMetaMethodConst (QMetaMethod) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QMetaMethodAccess =
  Private
  | Protected
  | Public
  | UnknownQMetaMethodAccess (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QMetaMethodAccess where
  fromCppEnum Private = 0
  fromCppEnum Protected = 1
  fromCppEnum Public = 2
  fromCppEnum (UnknownQMetaMethodAccess n) = n
  
  toCppEnum (0) = Private
  toCppEnum (1) = Protected
  toCppEnum (2) = Public
  toCppEnum n = UnknownQMetaMethodAccess n

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

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

data QMetaMethodMethodType =
  Method
  | Signal
  | Slot
  | Constructor
  | UnknownQMetaMethodMethodType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QMetaMethodMethodType where
  fromCppEnum Method = 0
  fromCppEnum Signal = 1
  fromCppEnum Slot = 2
  fromCppEnum Constructor = 3
  fromCppEnum (UnknownQMetaMethodMethodType n) = n
  
  toCppEnum (0) = Method
  toCppEnum (1) = Signal
  toCppEnum (2) = Slot
  toCppEnum (3) = Constructor
  toCppEnum n = UnknownQMetaMethodMethodType n

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

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