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

module Graphics.UI.Qtah.Generated.Core.QMetaEnum (
  QMetaEnumValue (..),
  QMetaEnumConstPtr (..),
  enumName,
  isFlag,
  isScoped,
  isValid,
  key,
  keyCount,
  keyToValue,
  keyToValueWithPtrBool,
  keysToValue,
  keysToValueWithPtrBool,
  name,
  scope,
  value,
  valueToKey,
  valueToKeys,
  QMetaEnumPtr (..),
  QMetaEnumConst (..),
  castQMetaEnumToConst,
  QMetaEnum (..),
  castQMetaEnumToNonconst,
  newCopy,
  QMetaEnumSuper (..),
  QMetaEnumSuperConst (..),
  ) 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 Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QMetaEnum_newCopy" newCopy' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO (HoppyF.Ptr QMetaEnum)
foreign import ccall "genpop__QMetaEnum_enumName" enumName' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaEnum_isFlag" isFlag' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaEnum_isScoped" isScoped' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaEnum_isValid" isValid' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaEnum_key" key' ::  HoppyF.Ptr QMetaEnumConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaEnum_keyCount" keyCount' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_keyToValue" keyToValue' ::  HoppyF.Ptr QMetaEnumConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_keyToValueWithPtrBool" keyToValueWithPtrBool' ::  HoppyF.Ptr QMetaEnumConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_keysToValue" keysToValue' ::  HoppyF.Ptr QMetaEnumConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_keysToValueWithPtrBool" keysToValueWithPtrBool' ::  HoppyF.Ptr QMetaEnumConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CBool -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_name" name' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaEnum_scope" scope' ::  HoppyF.Ptr QMetaEnumConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaEnum_value" value' ::  HoppyF.Ptr QMetaEnumConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaEnum_valueToKey" valueToKey' ::  HoppyF.Ptr QMetaEnumConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaEnum_valueToKeys" valueToKeys' ::  HoppyF.Ptr QMetaEnumConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "gendel__QMetaEnum" delete'QMetaEnum :: HoppyF.Ptr QMetaEnumConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMetaEnum" deletePtr'QMetaEnum :: HoppyF.FunPtr (HoppyF.Ptr QMetaEnumConst -> HoppyP.IO ())

class QMetaEnumValue a where
  withQMetaEnumPtr :: a -> (QMetaEnumConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMetaEnumConstPtr a => QMetaEnumValue a where
  withQMetaEnumPtr = HoppyP.flip ($) . toQMetaEnumConst

class (HoppyFHR.CppPtr this) => QMetaEnumConstPtr this where
  toQMetaEnumConst :: this -> QMetaEnumConst

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

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

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

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

key :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
key arg'1 arg'2 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (key' arg'1' arg'2')

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

keyToValue :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
keyToValue arg'1 arg'2 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (keyToValue' arg'1' arg'2')

keyToValueWithPtrBool :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyP.Int)
keyToValueWithPtrBool arg'1 arg'2 arg'3 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (keyToValueWithPtrBool' arg'1' arg'2' arg'3')

keysToValue :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
keysToValue arg'1 arg'2 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (keysToValue' arg'1' arg'2')

keysToValueWithPtrBool :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CBool) -> (HoppyP.IO HoppyP.Int)
keysToValueWithPtrBool arg'1 arg'2 arg'3 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (keysToValueWithPtrBool' arg'1' arg'2' arg'3')

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

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

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

valueToKey :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
valueToKey arg'1 arg'2 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (valueToKey' arg'1' arg'2')

valueToKeys :: (QMetaEnumValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahDBS.ByteString)
valueToKeys arg'1 arg'2 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (valueToKeys' arg'1' arg'2')

class (QMetaEnumConstPtr this) => QMetaEnumPtr this where
  toQMetaEnum :: this -> QMetaEnum

data QMetaEnumConst =
    QMetaEnumConst (HoppyF.Ptr QMetaEnumConst)
  | QMetaEnumConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaEnumConst)
  deriving (HoppyP.Show)

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

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

castQMetaEnumToConst :: QMetaEnum -> QMetaEnumConst
castQMetaEnumToConst (QMetaEnum ptr') = QMetaEnumConst $ HoppyF.castPtr ptr'
castQMetaEnumToConst (QMetaEnumGc fptr' ptr') = QMetaEnumConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaEnumConst QMetaEnum where copy = newCopy

instance QMetaEnumConstPtr QMetaEnumConst where
  toQMetaEnumConst = HoppyP.id

data QMetaEnum =
    QMetaEnum (HoppyF.Ptr QMetaEnum)
  | QMetaEnumGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaEnum)
  deriving (HoppyP.Show)

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

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

castQMetaEnumToNonconst :: QMetaEnumConst -> QMetaEnum
castQMetaEnumToNonconst (QMetaEnumConst ptr') = QMetaEnum $ HoppyF.castPtr ptr'
castQMetaEnumToNonconst (QMetaEnumConstGc fptr' ptr') = QMetaEnumGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaEnum QMetaEnum where copy = newCopy

instance QMetaEnumConstPtr QMetaEnum where
  toQMetaEnumConst (QMetaEnum ptr') = QMetaEnumConst $ (HoppyF.castPtr :: HoppyF.Ptr QMetaEnum -> HoppyF.Ptr QMetaEnumConst) ptr'
  toQMetaEnumConst (QMetaEnumGc fptr' ptr') = QMetaEnumConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMetaEnum -> HoppyF.Ptr QMetaEnumConst) ptr'

instance QMetaEnumPtr QMetaEnum where
  toQMetaEnum = HoppyP.id

newCopy :: (QMetaEnumValue arg'1) => (arg'1) -> (HoppyP.IO QMetaEnum)
newCopy arg'1 =
  withQMetaEnumPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QMetaEnum
  (newCopy' arg'1')

class QMetaEnumSuper a where
  downToQMetaEnum :: a -> QMetaEnum


class QMetaEnumSuperConst a where
  downToQMetaEnumConst :: a -> QMetaEnumConst


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

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

instance HoppyFHR.Decodable QMetaEnum (QMetaEnum) where
  decode = HoppyFHR.decode . toQMetaEnumConst

instance HoppyFHR.Decodable QMetaEnumConst (QMetaEnum) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc