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

module Graphics.UI.Qtah.Generated.Core.QMessageLogger (
  QMessageLoggerValue (..),
  QMessageLoggerConstPtr (..),
  critical,
  debug,
  info,
  warning,
  QMessageLoggerPtr (..),
  QMessageLoggerConst (..),
  castQMessageLoggerToConst,
  QMessageLogger (..),
  castQMessageLoggerToNonconst,
  new,
  newWithContext,
  newWithContextAndCategory,
  QMessageLoggerSuper (..),
  QMessageLoggerSuperConst (..),
  ) 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.QDebug as M26
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QMessageLogger_new" new' ::  HoppyP.IO (HoppyF.Ptr QMessageLogger)
foreign import ccall "genpop__QMessageLogger_newWithContext" newWithContext' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QMessageLogger)
foreign import ccall "genpop__QMessageLogger_newWithContextAndCategory" newWithContextAndCategory' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QMessageLogger)
foreign import ccall "genpop__QMessageLogger_critical" critical' ::  HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO (HoppyF.Ptr M26.QDebugConst)
foreign import ccall "genpop__QMessageLogger_debug" debug' ::  HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO (HoppyF.Ptr M26.QDebugConst)
foreign import ccall "genpop__QMessageLogger_info" info' ::  HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO (HoppyF.Ptr M26.QDebugConst)
foreign import ccall "genpop__QMessageLogger_warning" warning' ::  HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO (HoppyF.Ptr M26.QDebugConst)
foreign import ccall "gendel__QMessageLogger" delete'QMessageLogger :: HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMessageLogger" deletePtr'QMessageLogger :: HoppyF.FunPtr (HoppyF.Ptr QMessageLoggerConst -> HoppyP.IO ())

class QMessageLoggerValue a where
  withQMessageLoggerPtr :: a -> (QMessageLoggerConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMessageLoggerConstPtr a => QMessageLoggerValue a where
  withQMessageLoggerPtr = HoppyP.flip ($) . toQMessageLoggerConst

class (HoppyFHR.CppPtr this) => QMessageLoggerConstPtr this where
  toQMessageLoggerConst :: this -> QMessageLoggerConst

critical :: (QMessageLoggerValue this) => (this) {- ^ this -} -> (HoppyP.IO M26.QDebug)
critical arg'1 =
  withQMessageLoggerPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M26.QDebugConst) =<<
  (critical' arg'1')

debug :: (QMessageLoggerValue this) => (this) {- ^ this -} -> (HoppyP.IO M26.QDebug)
debug arg'1 =
  withQMessageLoggerPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M26.QDebugConst) =<<
  (debug' arg'1')

info :: (QMessageLoggerValue this) => (this) {- ^ this -} -> (HoppyP.IO M26.QDebug)
info arg'1 =
  withQMessageLoggerPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M26.QDebugConst) =<<
  (info' arg'1')

warning :: (QMessageLoggerValue this) => (this) {- ^ this -} -> (HoppyP.IO M26.QDebug)
warning arg'1 =
  withQMessageLoggerPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M26.QDebugConst) =<<
  (warning' arg'1')

class (QMessageLoggerConstPtr this) => QMessageLoggerPtr this where
  toQMessageLogger :: this -> QMessageLogger

data QMessageLoggerConst =
    QMessageLoggerConst (HoppyF.Ptr QMessageLoggerConst)
  | QMessageLoggerConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMessageLoggerConst)
  deriving (HoppyP.Show)

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

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

castQMessageLoggerToConst :: QMessageLogger -> QMessageLoggerConst
castQMessageLoggerToConst (QMessageLogger ptr') = QMessageLoggerConst $ HoppyF.castPtr ptr'
castQMessageLoggerToConst (QMessageLoggerGc fptr' ptr') = QMessageLoggerConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMessageLoggerConstPtr QMessageLoggerConst where
  toQMessageLoggerConst = HoppyP.id

data QMessageLogger =
    QMessageLogger (HoppyF.Ptr QMessageLogger)
  | QMessageLoggerGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMessageLogger)
  deriving (HoppyP.Show)

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

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

castQMessageLoggerToNonconst :: QMessageLoggerConst -> QMessageLogger
castQMessageLoggerToNonconst (QMessageLoggerConst ptr') = QMessageLogger $ HoppyF.castPtr ptr'
castQMessageLoggerToNonconst (QMessageLoggerConstGc fptr' ptr') = QMessageLoggerGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMessageLoggerConstPtr QMessageLogger where
  toQMessageLoggerConst (QMessageLogger ptr') = QMessageLoggerConst $ (HoppyF.castPtr :: HoppyF.Ptr QMessageLogger -> HoppyF.Ptr QMessageLoggerConst) ptr'
  toQMessageLoggerConst (QMessageLoggerGc fptr' ptr') = QMessageLoggerConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMessageLogger -> HoppyF.Ptr QMessageLoggerConst) ptr'

instance QMessageLoggerPtr QMessageLogger where
  toQMessageLogger = HoppyP.id

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

newWithContext :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QMessageLogger)
newWithContext arg'1 arg'2 arg'3 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QMessageLogger
  (newWithContext' arg'1' arg'2' arg'3')

newWithContextAndCategory :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QMessageLogger)
newWithContextAndCategory arg'1 arg'2 arg'3 arg'4 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  let arg'4' = arg'4 in
  HoppyP.fmap QMessageLogger
  (newWithContextAndCategory' arg'1' arg'2' arg'3' arg'4')

class QMessageLoggerSuper a where
  downToQMessageLogger :: a -> QMessageLogger


class QMessageLoggerSuperConst a where
  downToQMessageLoggerConst :: a -> QMessageLoggerConst


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

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