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

module Graphics.UI.Qtah.Generated.Core.QProcessEnvironment (
  QProcessEnvironmentValue (..),
  QProcessEnvironmentConstPtr (..),
  contains,
  isEmpty,
  keys,
  toStringList,
  value,
  valueWithDefault,
  eQ,
  nE,
  QProcessEnvironmentPtr (..),
  clear,
  insertWithName,
  insert,
  remove,
  swap,
  aSSIGN,
  systemEnvironment,
  QProcessEnvironmentConst (..),
  castQProcessEnvironmentToConst,
  QProcessEnvironment (..),
  castQProcessEnvironmentToNonconst,
  new,
  newCopy,
  QProcessEnvironmentSuper (..),
  QProcessEnvironmentSuperConst (..),
  ) where

import Control.Monad ((>=>))
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.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import Prelude (($), (.), (/=), (=<<), (==), (>>))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QProcessEnvironment_new" new' ::  HoppyP.IO (HoppyF.Ptr QProcessEnvironment)
foreign import ccall "genpop__QProcessEnvironment_newCopy" newCopy' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO (HoppyF.Ptr QProcessEnvironment)
foreign import ccall "genpop__QProcessEnvironment_clear" clear' ::  HoppyF.Ptr QProcessEnvironment -> HoppyP.IO ()
foreign import ccall "genpop__QProcessEnvironment_contains" contains' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcessEnvironment_insertWithName" insertWithName' ::  HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcessEnvironment_insert" insert' ::  HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcessEnvironment_isEmpty" isEmpty' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcessEnvironment_keys" keys' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QProcessEnvironment_remove" remove' ::  HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcessEnvironment_swap" swap' ::  HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr QProcessEnvironment -> HoppyP.IO ()
foreign import ccall "genpop__QProcessEnvironment_toStringList" toStringList' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QProcessEnvironment_value" value' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QProcessEnvironment_valueWithDefault" valueWithDefault' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QProcessEnvironment_systemEnvironment" systemEnvironment' ::  HoppyP.IO (HoppyF.Ptr QProcessEnvironmentConst)
foreign import ccall "genpop__QProcessEnvironment_EQ" eQ' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcessEnvironment_NE" nE' ::  HoppyF.Ptr QProcessEnvironmentConst -> HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcessEnvironment_ASSIGN" aSSIGN' ::  HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO (HoppyF.Ptr QProcessEnvironment)
foreign import ccall "gendel__QProcessEnvironment" delete'QProcessEnvironment :: HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO ()
foreign import ccall "&gendel__QProcessEnvironment" deletePtr'QProcessEnvironment :: HoppyF.FunPtr (HoppyF.Ptr QProcessEnvironmentConst -> HoppyP.IO ())

class QProcessEnvironmentValue a where
  withQProcessEnvironmentPtr :: a -> (QProcessEnvironmentConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QProcessEnvironmentConstPtr a => QProcessEnvironmentValue a where
  withQProcessEnvironmentPtr = HoppyP.flip ($) . toQProcessEnvironmentConst

class (HoppyFHR.CppPtr this) => QProcessEnvironmentConstPtr this where
  toQProcessEnvironmentConst :: this -> QProcessEnvironmentConst

contains :: (QProcessEnvironmentValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

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

keys :: (QProcessEnvironmentValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
keys arg'1 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (keys' arg'1')

toStringList :: (QProcessEnvironmentValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
toStringList arg'1 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (toStringList' arg'1')

value :: (QProcessEnvironmentValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
value arg'1 arg'2 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (value' arg'1' arg'2')

valueWithDefault :: (QProcessEnvironmentValue this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO QtahP.String)
valueWithDefault arg'1 arg'2 arg'3 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (valueWithDefault' arg'1' arg'2' arg'3')

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

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

class (QProcessEnvironmentConstPtr this) => QProcessEnvironmentPtr this where
  toQProcessEnvironment :: this -> QProcessEnvironment

clear :: (QProcessEnvironmentPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  (clear' arg'1')

insertWithName :: (QProcessEnvironmentPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
insertWithName arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insertWithName' arg'1' arg'2' arg'3')

insert :: (QProcessEnvironmentPtr this, QProcessEnvironmentValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
insert arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  withQProcessEnvironmentPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (insert' arg'1' arg'2')

remove :: (QProcessEnvironmentPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
remove arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (remove' arg'1' arg'2')

swap :: (QProcessEnvironmentPtr this, QProcessEnvironmentPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QProcessEnvironmentPtr this, QProcessEnvironmentValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QProcessEnvironment)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcessEnvironment arg'1) $ \arg'1' ->
  withQProcessEnvironmentPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QProcessEnvironment
  (aSSIGN' arg'1' arg'2')

systemEnvironment :: (HoppyP.IO QProcessEnvironment)
systemEnvironment =
  (HoppyFHR.decodeAndDelete . QProcessEnvironmentConst) =<<
  (systemEnvironment')

data QProcessEnvironmentConst =
    QProcessEnvironmentConst (HoppyF.Ptr QProcessEnvironmentConst)
  | QProcessEnvironmentConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QProcessEnvironmentConst)
  deriving (HoppyP.Show)

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

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

castQProcessEnvironmentToConst :: QProcessEnvironment -> QProcessEnvironmentConst
castQProcessEnvironmentToConst (QProcessEnvironment ptr') = QProcessEnvironmentConst $ HoppyF.castPtr ptr'
castQProcessEnvironmentToConst (QProcessEnvironmentGc fptr' ptr') = QProcessEnvironmentConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QProcessEnvironmentConst QProcessEnvironment where copy = newCopy

instance QProcessEnvironmentConstPtr QProcessEnvironmentConst where
  toQProcessEnvironmentConst = HoppyP.id

data QProcessEnvironment =
    QProcessEnvironment (HoppyF.Ptr QProcessEnvironment)
  | QProcessEnvironmentGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QProcessEnvironment)
  deriving (HoppyP.Show)

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

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

castQProcessEnvironmentToNonconst :: QProcessEnvironmentConst -> QProcessEnvironment
castQProcessEnvironmentToNonconst (QProcessEnvironmentConst ptr') = QProcessEnvironment $ HoppyF.castPtr ptr'
castQProcessEnvironmentToNonconst (QProcessEnvironmentConstGc fptr' ptr') = QProcessEnvironmentGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QProcessEnvironment QProcessEnvironment where copy = newCopy

instance QProcessEnvironmentConstPtr QProcessEnvironment where
  toQProcessEnvironmentConst (QProcessEnvironment ptr') = QProcessEnvironmentConst $ (HoppyF.castPtr :: HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr QProcessEnvironmentConst) ptr'
  toQProcessEnvironmentConst (QProcessEnvironmentGc fptr' ptr') = QProcessEnvironmentConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QProcessEnvironment -> HoppyF.Ptr QProcessEnvironmentConst) ptr'

instance QProcessEnvironmentPtr QProcessEnvironment where
  toQProcessEnvironment = HoppyP.id

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

newCopy :: (QProcessEnvironmentValue arg'1) => (arg'1) -> (HoppyP.IO QProcessEnvironment)
newCopy arg'1 =
  withQProcessEnvironmentPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QProcessEnvironment
  (newCopy' arg'1')

class QProcessEnvironmentSuper a where
  downToQProcessEnvironment :: a -> QProcessEnvironment


class QProcessEnvironmentSuperConst a where
  downToQProcessEnvironmentConst :: a -> QProcessEnvironmentConst


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

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

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

instance HoppyFHR.Decodable QProcessEnvironment (QProcessEnvironment) where
  decode = HoppyFHR.decode . toQProcessEnvironmentConst

instance HoppyFHR.Decodable QProcessEnvironmentConst (QProcessEnvironment) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc