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

module Graphics.UI.Qtah.Generated.Core.QStringList (
  castQStringListToQListQString,
  QStringListValue (..),
  QStringListConstPtr (..),
  containsCase,
  filter,
  filterCase,
  joinString,
  joinChar,
  eQ,
  nE,
  QStringListPtr (..),
  removeDuplicates,
  sort,
  sortCase,
  aSSIGN,
  QStringListConst (..),
  castQStringListToConst,
  QStringList (..),
  castQStringListToNonconst,
  new,
  newCopy,
  QStringListSuper (..),
  QStringListSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Generated.Core.QChar as M16
import qualified Graphics.UI.Qtah.Generated.Core.QList.QString as M206
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QStringList_new" new' ::  HoppyP.IO (HoppyF.Ptr QStringList)
foreign import ccall "genpop__QStringList_newCopy" newCopy' ::  HoppyF.Ptr QStringListConst -> HoppyP.IO (HoppyF.Ptr QStringList)
foreign import ccall "genpop__QStringList_containsCase" containsCase' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStringList_filter" filter' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QStringListConst)
foreign import ccall "genpop__QStringList_filterCase" filterCase' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStringListConst)
foreign import ccall "genpop__QStringList_joinString" joinString' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStringList_joinChar" joinChar' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStringList_removeDuplicates" removeDuplicates' ::  HoppyF.Ptr QStringList -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStringList_sort" sort' ::  HoppyF.Ptr QStringList -> HoppyP.IO ()
foreign import ccall "genpop__QStringList_sortCase" sortCase' ::  HoppyF.Ptr QStringList -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStringList_EQ" eQ' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr QStringListConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStringList_NE" nE' ::  HoppyF.Ptr QStringListConst -> HoppyF.Ptr QStringListConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStringList_ASSIGN" aSSIGN' ::  HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst -> HoppyP.IO (HoppyF.Ptr QStringList)
foreign import ccall "gencast__QStringList__QListQString" castQStringListToQListQString :: HoppyF.Ptr QStringListConst -> HoppyF.Ptr M206.QListQStringConst
foreign import ccall "gendel__QStringList" delete'QStringList :: HoppyF.Ptr QStringListConst -> HoppyP.IO ()
foreign import ccall "&gendel__QStringList" deletePtr'QStringList :: HoppyF.FunPtr (HoppyF.Ptr QStringListConst -> HoppyP.IO ())

class QStringListValue a where
  withQStringListPtr :: a -> (QStringListConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QStringListConstPtr a => QStringListValue a where
  withQStringListPtr = HoppyP.flip ($) . toQStringListConst

instance {-# OVERLAPPING #-} QStringListValue ([QtahP.String]) where
  withQStringListPtr = HoppyFHR.withCppObj

class (M206.QListQStringConstPtr this) => QStringListConstPtr this where
  toQStringListConst :: this -> QStringListConst

containsCase :: (QStringListValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Bool)
containsCase arg'1 arg'2 arg'3 =
  withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (containsCase' arg'1' arg'2' arg'3')

filter :: (QStringListValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO [QtahP.String])
filter arg'1 arg'2 =
  withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QStringListConst) =<<
  (filter' arg'1' arg'2')

filterCase :: (QStringListValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO [QtahP.String])
filterCase arg'1 arg'2 arg'3 =
  withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QStringListConst) =<<
  (filterCase' arg'1' arg'2' arg'3')

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

joinChar :: (QStringListValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
joinChar arg'1 arg'2 =
  withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (joinChar' arg'1' arg'2')

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

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

class (QStringListConstPtr this, M206.QListQStringPtr this) => QStringListPtr this where
  toQStringList :: this -> QStringList

removeDuplicates :: (QStringListPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
removeDuplicates arg'1 =
  HoppyFHR.withCppPtr (toQStringList arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeDuplicates' arg'1')

sort :: (QStringListPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
sort arg'1 =
  HoppyFHR.withCppPtr (toQStringList arg'1) $ \arg'1' ->
  (sort' arg'1')

sortCase :: (QStringListPtr this) => (this) {- ^ this -} -> (M190.QtCaseSensitivity) -> (HoppyP.IO ())
sortCase arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStringList arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (sortCase' arg'1' arg'2')

aSSIGN :: (QStringListPtr this, QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QStringList)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStringList arg'1) $ \arg'1' ->
  withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QStringList
  (aSSIGN' arg'1' arg'2')

data QStringListConst =
    QStringListConst (HoppyF.Ptr QStringListConst)
  | QStringListConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStringListConst)
  deriving (HoppyP.Show)

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

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

castQStringListToConst :: QStringList -> QStringListConst
castQStringListToConst (QStringList ptr') = QStringListConst $ HoppyF.castPtr ptr'
castQStringListToConst (QStringListGc fptr' ptr') = QStringListConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QStringListConst QStringList where copy = newCopy

instance QStringListConstPtr QStringListConst where
  toQStringListConst = HoppyP.id

instance M206.QListQStringConstPtr QStringListConst where
  toQListQStringConst (QStringListConst ptr') = M206.QListQStringConst $ castQStringListToQListQString ptr'
  toQListQStringConst (QStringListConstGc fptr' ptr') = M206.QListQStringConstGc fptr' $ castQStringListToQListQString ptr'

data QStringList =
    QStringList (HoppyF.Ptr QStringList)
  | QStringListGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStringList)
  deriving (HoppyP.Show)

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

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

castQStringListToNonconst :: QStringListConst -> QStringList
castQStringListToNonconst (QStringListConst ptr') = QStringList $ HoppyF.castPtr ptr'
castQStringListToNonconst (QStringListConstGc fptr' ptr') = QStringListGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QStringList QStringList where copy = newCopy

instance QStringListConstPtr QStringList where
  toQStringListConst (QStringList ptr') = QStringListConst $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'
  toQStringListConst (QStringListGc fptr' ptr') = QStringListConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'

instance QStringListPtr QStringList where
  toQStringList = HoppyP.id

instance M206.QListQStringConstPtr QStringList where
  toQListQStringConst (QStringList ptr') = M206.QListQStringConst $ castQStringListToQListQString $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'
  toQListQStringConst (QStringListGc fptr' ptr') = M206.QListQStringConstGc fptr' $ castQStringListToQListQString $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'

instance M206.QListQStringPtr QStringList where
  toQListQString (QStringList ptr') = M206.QListQString $ (HoppyF.castPtr :: HoppyF.Ptr M206.QListQStringConst -> HoppyF.Ptr M206.QListQString) $ castQStringListToQListQString $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'
  toQListQString (QStringListGc fptr' ptr') = M206.QListQStringGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M206.QListQStringConst -> HoppyF.Ptr M206.QListQString) $ castQStringListToQListQString $ (HoppyF.castPtr :: HoppyF.Ptr QStringList -> HoppyF.Ptr QStringListConst) ptr'

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

newCopy :: (QStringListValue arg'1) => (arg'1) -> (HoppyP.IO QStringList)
newCopy arg'1 =
  withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QStringList
  (newCopy' arg'1')

class QStringListSuper a where
  downToQStringList :: a -> QStringList


class QStringListSuperConst a where
  downToQStringListConst :: a -> QStringListConst


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

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

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

instance HoppyFHR.Encodable QStringList ([QtahP.String]) where
  encode =
    QtahFHR.fromContents

instance HoppyFHR.Encodable QStringListConst ([QtahP.String]) where
  encode = HoppyP.fmap (toQStringListConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QStringList)

instance HoppyFHR.Decodable QStringList ([QtahP.String]) where
  decode = HoppyFHR.decode . toQStringListConst

instance HoppyFHR.Decodable QStringListConst ([QtahP.String]) where
  decode =
    QtahFHR.toContents

instance QtahFHR.HasContents QStringListConst QtahP.String where
  toContents = QtahFHR.toContents . M206.toQListQStringConst

instance QtahFHR.HasContents QStringList QtahP.String where
  toContents = QtahFHR.toContents . M206.toQListQStringConst

instance QtahFHR.FromContents QStringList QtahP.String where
  fromContents strs' = do
    l' <- new
    QtahP.mapM_ (M206.append l') strs'
    QtahP.return l'