Connection.hs

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

module Graphics.UI.Qtah.Generated.Core.QMetaObject.Connection (
  ConnectionValue (..),
  ConnectionConstPtr (..),
  isValid,
  ConnectionPtr (..),
  aSSIGN,
  ConnectionConst (..),
  castConnectionToConst,
  Connection (..),
  castConnectionToNonconst,
  new,
  newCopy,
  ConnectionSuper (..),
  ConnectionSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import Prelude (($), (.), (/=), (=<<), (==), (>>))
import qualified Prelude as HoppyP

foreign import ccall "genpop__Connection_new" new' ::  HoppyP.IO (HoppyF.Ptr Connection)
foreign import ccall "genpop__Connection_newCopy" newCopy' ::  HoppyF.Ptr ConnectionConst -> HoppyP.IO (HoppyF.Ptr Connection)
foreign import ccall "genpop__Connection_isValid" isValid' ::  HoppyF.Ptr ConnectionConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__Connection_ASSIGN" aSSIGN' ::  HoppyF.Ptr Connection -> HoppyF.Ptr ConnectionConst -> HoppyP.IO (HoppyF.Ptr Connection)
foreign import ccall "gendel__Connection" delete'Connection :: HoppyF.Ptr ConnectionConst -> HoppyP.IO ()
foreign import ccall "&gendel__Connection" deletePtr'Connection :: HoppyF.FunPtr (HoppyF.Ptr ConnectionConst -> HoppyP.IO ())

class ConnectionValue a where
  withConnectionPtr :: a -> (ConnectionConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} ConnectionConstPtr a => ConnectionValue a where
  withConnectionPtr = HoppyP.flip ($) . toConnectionConst

class (HoppyFHR.CppPtr this) => ConnectionConstPtr this where
  toConnectionConst :: this -> ConnectionConst

isValid :: (ConnectionValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
isValid arg'1 =
  withConnectionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isValid' arg'1')

class (ConnectionConstPtr this) => ConnectionPtr this where
  toConnection :: this -> Connection

aSSIGN :: (ConnectionPtr this, ConnectionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO Connection)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toConnection arg'1) $ \arg'1' ->
  withConnectionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap Connection
  (aSSIGN' arg'1' arg'2')

data ConnectionConst =
    ConnectionConst (HoppyF.Ptr ConnectionConst)
  | ConnectionConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ConnectionConst)
  deriving (HoppyP.Show)

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

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

castConnectionToConst :: Connection -> ConnectionConst
castConnectionToConst (Connection ptr') = ConnectionConst $ HoppyF.castPtr ptr'
castConnectionToConst (ConnectionGc fptr' ptr') = ConnectionConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable ConnectionConst Connection where copy = newCopy

instance ConnectionConstPtr ConnectionConst where
  toConnectionConst = HoppyP.id

data Connection =
    Connection (HoppyF.Ptr Connection)
  | ConnectionGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr Connection)
  deriving (HoppyP.Show)

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

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

castConnectionToNonconst :: ConnectionConst -> Connection
castConnectionToNonconst (ConnectionConst ptr') = Connection $ HoppyF.castPtr ptr'
castConnectionToNonconst (ConnectionConstGc fptr' ptr') = ConnectionGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable Connection Connection where copy = newCopy

instance ConnectionConstPtr Connection where
  toConnectionConst (Connection ptr') = ConnectionConst $ (HoppyF.castPtr :: HoppyF.Ptr Connection -> HoppyF.Ptr ConnectionConst) ptr'
  toConnectionConst (ConnectionGc fptr' ptr') = ConnectionConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr Connection -> HoppyF.Ptr ConnectionConst) ptr'

instance ConnectionPtr Connection where
  toConnection = HoppyP.id

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

newCopy :: (ConnectionValue arg'1) => (arg'1) -> (HoppyP.IO Connection)
newCopy arg'1 =
  withConnectionPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap Connection
  (newCopy' arg'1')

class ConnectionSuper a where
  downToConnection :: a -> Connection


class ConnectionSuperConst a where
  downToConnectionConst :: a -> ConnectionConst


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

instance ConnectionValue a => HoppyFHR.Assignable Connection a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable Connection (Connection) where
  decode = HoppyFHR.decode . toConnectionConst

instance HoppyFHR.Decodable ConnectionConst (Connection) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc