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

module Graphics.UI.Qtah.Generated.Core.QList.QVariant (
  QListQVariantValue (..),
  QListQVariantConstPtr (..),
  atConst,
  contains,
  count,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QListQVariantPtr (..),
  append,
  appendList,
  at,
  clear,
  first,
  insert,
  last,
  move,
  prepend,
  removeAll,
  removeAt,
  removeFirst,
  removeLast,
  removeOne,
  replace,
  reserve,
  swap,
  takeAt,
  takeFirst,
  takeLast,
  aSSIGN,
  QListQVariantConst (..),
  castQListQVariantToConst,
  QListQVariant (..),
  castQListQVariantToNonconst,
  new,
  newCopy,
  QListQVariantSuper (..),
  QListQVariantSuperConst (..),
  ) where

import Control.Monad ((<=<))
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 {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QVariant as M168
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QListQVariant_new" new' ::  HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "genpop__QListQVariant_newCopy" newCopy' ::  HoppyF.Ptr QListQVariantConst -> HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "genpop__QListQVariant_append" append' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_appendList" appendList' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr QListQVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_at" at' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariant)
foreign import ccall "genpop__QListQVariant_atConst" atConst' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_clear" clear' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_contains" contains' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQVariant_count" count' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_endsWith" endsWith' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQVariant_first" first' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO (HoppyF.Ptr M168.QVariant)
foreign import ccall "genpop__QListQVariant_firstConst" firstConst' ::  HoppyF.Ptr QListQVariantConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_get" get' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_indexOf" indexOf' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_insert" insert' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_isEmpty" isEmpty' ::  HoppyF.Ptr QListQVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQVariant_last" last' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO (HoppyF.Ptr M168.QVariant)
foreign import ccall "genpop__QListQVariant_lastConst" lastConst' ::  HoppyF.Ptr QListQVariantConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_mid" mid' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "genpop__QListQVariant_midLength" midLength' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "genpop__QListQVariant_move" move' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_prepend" prepend' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_removeAll" removeAll' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_removeAt" removeAt' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_removeFirst" removeFirst' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_removeLast" removeLast' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_removeOne" removeOne' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQVariant_replace" replace' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_reserve" reserve' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_size" size' ::  HoppyF.Ptr QListQVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQVariant_startsWith" startsWith' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQVariant_swap" swap' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQVariant_takeAt" takeAt' ::  HoppyF.Ptr QListQVariant -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_takeFirst" takeFirst' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_takeLast" takeLast' ::  HoppyF.Ptr QListQVariant -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_value" value' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_valueOr" valueOr' ::  HoppyF.Ptr QListQVariantConst -> HoppyFC.CInt -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QListQVariant_ADD" aDD' ::  HoppyF.Ptr QListQVariantConst -> HoppyF.Ptr QListQVariantConst -> HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "genpop__QListQVariant_ASSIGN" aSSIGN' ::  HoppyF.Ptr QListQVariant -> HoppyF.Ptr QListQVariantConst -> HoppyP.IO (HoppyF.Ptr QListQVariant)
foreign import ccall "gendel__QListQVariant" delete'QListQVariant :: HoppyF.Ptr QListQVariantConst -> HoppyP.IO ()
foreign import ccall "&gendel__QListQVariant" deletePtr'QListQVariant :: HoppyF.FunPtr (HoppyF.Ptr QListQVariantConst -> HoppyP.IO ())

class QListQVariantValue a where
  withQListQVariantPtr :: a -> (QListQVariantConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QListQVariantConstPtr a => QListQVariantValue a where
  withQListQVariantPtr = HoppyP.flip ($) . toQListQVariantConst

instance {-# OVERLAPPING #-} QListQVariantValue ([M168.QVariant]) where
  withQListQVariantPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QListQVariantConstPtr this where
  toQListQVariantConst :: this -> QListQVariantConst

atConst :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariantConst)
atConst arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M168.QVariantConst
  (atConst' arg'1' arg'2')

contains :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

count :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

endsWith :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWith arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWith' arg'1' arg'2')

firstConst :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariantConst)
firstConst arg'1 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M168.QVariantConst
  (firstConst' arg'1')

get :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariant)
get arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfFrom' arg'1' arg'2' arg'3')

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

lastConst :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariantConst)
lastConst arg'1 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M168.QVariantConst
  (lastConst' arg'1')

lastIndexOf :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfFrom' arg'1' arg'2' arg'3')

mid :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QListQVariant)
mid arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QListQVariant
  (mid' arg'1' arg'2')

midLength :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QListQVariant)
midLength arg'1 arg'2 arg'3 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QListQVariant
  (midLength' arg'1' arg'2' arg'3')

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

startsWith :: (QListQVariantValue this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWith arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWith' arg'1' arg'2')

value :: (QListQVariantValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariant)
value arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QListQVariantValue this, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO M168.QVariant)
valueOr arg'1 arg'2 arg'3 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

aDD :: (QListQVariantValue this, QListQVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QListQVariant)
aDD arg'1 arg'2 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQListQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QListQVariant
  (aDD' arg'1' arg'2')

class (QListQVariantConstPtr this) => QListQVariantPtr this where
  toQListQVariant :: this -> QListQVariant

append :: (QListQVariantPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (append' arg'1' arg'2')

appendList :: (QListQVariantPtr this, QListQVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendList arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  withQListQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendList' arg'1' arg'2')

at :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariant)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M168.QVariant
  (at' arg'1' arg'2')

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

first :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
first arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  HoppyP.fmap M168.QVariant
  (first' arg'1')

insert :: (QListQVariantPtr this, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

last :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
last arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  HoppyP.fmap M168.QVariant
  (last' arg'1')

move :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
move arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (move' arg'1' arg'2' arg'3')

prepend :: (QListQVariantPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (prepend' arg'1' arg'2')

removeAll :: (QListQVariantPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

removeAt :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
removeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (removeAt' arg'1' arg'2')

removeFirst :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
removeFirst arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (removeFirst' arg'1')

removeLast :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
removeLast arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (removeLast' arg'1')

removeOne :: (QListQVariantPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removeOne arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removeOne' arg'1' arg'2')

replace :: (QListQVariantPtr this, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

reserve :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
reserve arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (reserve' arg'1' arg'2')

swap :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
swap arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (swap' arg'1' arg'2' arg'3')

takeAt :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariant)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (takeFirst' arg'1')

takeLast :: (QListQVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QListQVariantPtr this, QListQVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QListQVariant)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQVariant arg'1) $ \arg'1' ->
  withQListQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QListQVariant
  (aSSIGN' arg'1' arg'2')

data QListQVariantConst =
    QListQVariantConst (HoppyF.Ptr QListQVariantConst)
  | QListQVariantConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQVariantConst)
  deriving (HoppyP.Show)

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

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

castQListQVariantToConst :: QListQVariant -> QListQVariantConst
castQListQVariantToConst (QListQVariant ptr') = QListQVariantConst $ HoppyF.castPtr ptr'
castQListQVariantToConst (QListQVariantGc fptr' ptr') = QListQVariantConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQVariantConst QListQVariant where copy = newCopy

instance QListQVariantConstPtr QListQVariantConst where
  toQListQVariantConst = HoppyP.id

data QListQVariant =
    QListQVariant (HoppyF.Ptr QListQVariant)
  | QListQVariantGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQVariant)
  deriving (HoppyP.Show)

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

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

castQListQVariantToNonconst :: QListQVariantConst -> QListQVariant
castQListQVariantToNonconst (QListQVariantConst ptr') = QListQVariant $ HoppyF.castPtr ptr'
castQListQVariantToNonconst (QListQVariantConstGc fptr' ptr') = QListQVariantGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQVariant QListQVariant where copy = newCopy

instance QListQVariantConstPtr QListQVariant where
  toQListQVariantConst (QListQVariant ptr') = QListQVariantConst $ (HoppyF.castPtr :: HoppyF.Ptr QListQVariant -> HoppyF.Ptr QListQVariantConst) ptr'
  toQListQVariantConst (QListQVariantGc fptr' ptr') = QListQVariantConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QListQVariant -> HoppyF.Ptr QListQVariantConst) ptr'

instance QListQVariantPtr QListQVariant where
  toQListQVariant = HoppyP.id

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

newCopy :: (QListQVariantValue arg'1) => (arg'1) -> (HoppyP.IO QListQVariant)
newCopy arg'1 =
  withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QListQVariant
  (newCopy' arg'1')

class QListQVariantSuper a where
  downToQListQVariant :: a -> QListQVariant


class QListQVariantSuperConst a where
  downToQListQVariantConst :: a -> QListQVariantConst


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

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

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

instance HoppyFHR.Encodable QListQVariant ([M168.QVariant]) where
  encode =
    QtahFHR.fromContents

instance HoppyFHR.Encodable QListQVariantConst ([M168.QVariant]) where
  encode = HoppyP.fmap (toQListQVariantConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QListQVariant)

instance HoppyFHR.Decodable QListQVariant ([M168.QVariant]) where
  decode = HoppyFHR.decode . toQListQVariantConst

instance HoppyFHR.Decodable QListQVariantConst ([M168.QVariant]) where
  decode =
    QtahFHR.toContents

instance QtahFHR.HasContents QListQVariantConst (M168.QVariant) where
  toContents this' = do
    size' <- size this'
    QtahP.mapM (QtahFHR.decode <=< atConst this') [0..size'-1]

instance QtahFHR.HasContents QListQVariant (M168.QVariant) where
  toContents this' = do
    size' <- size this'
    QtahP.mapM (QtahFHR.decode <=< at this') [0..size'-1]

instance QtahFHR.FromContents QListQVariant (M168.QVariant) where
  fromContents values' = do
    list' <- new
    reserve list' $ QtahFHR.coerceIntegral $ QtahP.length values'
    QtahP.mapM_ (append list') values'
    QtahP.return list'