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

module Graphics.UI.Qtah.Generated.Core.QList.QSize (
  QListQSizeValue (..),
  QListQSizeConstPtr (..),
  atConst,
  contains,
  count,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QListQSizePtr (..),
  append,
  appendList,
  at,
  clear,
  first,
  insert,
  last,
  move,
  prepend,
  removeAll,
  removeAt,
  removeFirst,
  removeLast,
  removeOne,
  replace,
  reserve,
  swap,
  takeAt,
  takeFirst,
  takeLast,
  aSSIGN,
  QListQSizeConst (..),
  castQListQSizeToConst,
  QListQSize (..),
  castQListQSizeToNonconst,
  new,
  newCopy,
  QListQSizeSuper (..),
  QListQSizeSuperConst (..),
  ) 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 qualified Graphics.UI.Qtah.Core.HSize as HSize
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M134
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QListQSize_new" new' ::  HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "genpop__QListQSize_newCopy" newCopy' ::  HoppyF.Ptr QListQSizeConst -> HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "genpop__QListQSize_append" append' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_appendList" appendList' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr QListQSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_at" at' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M134.QSize)
foreign import ccall "genpop__QListQSize_atConst" atConst' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_clear" clear' ::  HoppyF.Ptr QListQSize -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_contains" contains' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQSize_count" count' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_endsWith" endsWith' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQSize_first" first' ::  HoppyF.Ptr QListQSize -> HoppyP.IO (HoppyF.Ptr M134.QSize)
foreign import ccall "genpop__QListQSize_firstConst" firstConst' ::  HoppyF.Ptr QListQSizeConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_get" get' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_indexOf" indexOf' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_insert" insert' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_isEmpty" isEmpty' ::  HoppyF.Ptr QListQSizeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQSize_last" last' ::  HoppyF.Ptr QListQSize -> HoppyP.IO (HoppyF.Ptr M134.QSize)
foreign import ccall "genpop__QListQSize_lastConst" lastConst' ::  HoppyF.Ptr QListQSizeConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_mid" mid' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "genpop__QListQSize_midLength" midLength' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "genpop__QListQSize_move" move' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_prepend" prepend' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_removeAll" removeAll' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_removeAt" removeAt' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_removeFirst" removeFirst' ::  HoppyF.Ptr QListQSize -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_removeLast" removeLast' ::  HoppyF.Ptr QListQSize -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_removeOne" removeOne' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQSize_replace" replace' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_reserve" reserve' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_size" size' ::  HoppyF.Ptr QListQSizeConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQSize_startsWith" startsWith' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQSize_swap" swap' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQSize_takeAt" takeAt' ::  HoppyF.Ptr QListQSize -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_takeFirst" takeFirst' ::  HoppyF.Ptr QListQSize -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_takeLast" takeLast' ::  HoppyF.Ptr QListQSize -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_value" value' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_valueOr" valueOr' ::  HoppyF.Ptr QListQSizeConst -> HoppyFC.CInt -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QListQSize_ADD" aDD' ::  HoppyF.Ptr QListQSizeConst -> HoppyF.Ptr QListQSizeConst -> HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "genpop__QListQSize_ASSIGN" aSSIGN' ::  HoppyF.Ptr QListQSize -> HoppyF.Ptr QListQSizeConst -> HoppyP.IO (HoppyF.Ptr QListQSize)
foreign import ccall "gendel__QListQSize" delete'QListQSize :: HoppyF.Ptr QListQSizeConst -> HoppyP.IO ()
foreign import ccall "&gendel__QListQSize" deletePtr'QListQSize :: HoppyF.FunPtr (HoppyF.Ptr QListQSizeConst -> HoppyP.IO ())

class QListQSizeValue a where
  withQListQSizePtr :: a -> (QListQSizeConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QListQSizeConstPtr a => QListQSizeValue a where
  withQListQSizePtr = HoppyP.flip ($) . toQListQSizeConst

instance {-# OVERLAPPING #-} QListQSizeValue ([HSize.HSize]) where
  withQListQSizePtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QListQSizeConstPtr this where
  toQListQSizeConst :: this -> QListQSizeConst

atConst :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M134.QSizeConst)
atConst arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M134.QSizeConst
  (atConst' arg'1' arg'2')

contains :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

count :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

endsWith :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWith arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWith' arg'1' arg'2')

firstConst :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.IO M134.QSizeConst)
firstConst arg'1 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M134.QSizeConst
  (firstConst' arg'1')

get :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HSize.HSize)
get arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr 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 :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isEmpty arg'1 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEmpty' arg'1')

lastConst :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.IO M134.QSizeConst)
lastConst arg'1 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M134.QSizeConst
  (lastConst' arg'1')

lastIndexOf :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr 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 :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QListQSize)
mid arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QListQSize
  (mid' arg'1' arg'2')

midLength :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QListQSize)
midLength arg'1 arg'2 arg'3 =
  withQListQSizePtr 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 QListQSize
  (midLength' arg'1' arg'2' arg'3')

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

startsWith :: (QListQSizeValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWith arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWith' arg'1' arg'2')

value :: (QListQSizeValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HSize.HSize)
value arg'1 arg'2 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QListQSizeValue this, M134.QSizeValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO HSize.HSize)
valueOr arg'1 arg'2 arg'3 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M134.withQSizePtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

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

class (QListQSizeConstPtr this) => QListQSizePtr this where
  toQListQSize :: this -> QListQSize

append :: (QListQSizePtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (append' arg'1' arg'2')

appendList :: (QListQSizePtr this, QListQSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendList arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  withQListQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendList' arg'1' arg'2')

at :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M134.QSize)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M134.QSize
  (at' arg'1' arg'2')

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

first :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.IO M134.QSize)
first arg'1 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  HoppyP.fmap M134.QSize
  (first' arg'1')

insert :: (QListQSizePtr this, M134.QSizeValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M134.withQSizePtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

last :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.IO M134.QSize)
last arg'1 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  HoppyP.fmap M134.QSize
  (last' arg'1')

move :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
move arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQSize 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 :: (QListQSizePtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (prepend' arg'1' arg'2')

removeAll :: (QListQSizePtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

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

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

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

removeOne :: (QListQSizePtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removeOne arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removeOne' arg'1' arg'2')

replace :: (QListQSizePtr this, M134.QSizeValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M134.withQSizePtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

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

swap :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
swap arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQSize 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 :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HSize.HSize)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (takeFirst' arg'1')

takeLast :: (QListQSizePtr this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QListQSizePtr this, QListQSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QListQSize)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQSize arg'1) $ \arg'1' ->
  withQListQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QListQSize
  (aSSIGN' arg'1' arg'2')

data QListQSizeConst =
    QListQSizeConst (HoppyF.Ptr QListQSizeConst)
  | QListQSizeConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQSizeConst)
  deriving (HoppyP.Show)

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

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

castQListQSizeToConst :: QListQSize -> QListQSizeConst
castQListQSizeToConst (QListQSize ptr') = QListQSizeConst $ HoppyF.castPtr ptr'
castQListQSizeToConst (QListQSizeGc fptr' ptr') = QListQSizeConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQSizeConst QListQSize where copy = newCopy

instance QListQSizeConstPtr QListQSizeConst where
  toQListQSizeConst = HoppyP.id

data QListQSize =
    QListQSize (HoppyF.Ptr QListQSize)
  | QListQSizeGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQSize)
  deriving (HoppyP.Show)

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

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

castQListQSizeToNonconst :: QListQSizeConst -> QListQSize
castQListQSizeToNonconst (QListQSizeConst ptr') = QListQSize $ HoppyF.castPtr ptr'
castQListQSizeToNonconst (QListQSizeConstGc fptr' ptr') = QListQSizeGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQSize QListQSize where copy = newCopy

instance QListQSizeConstPtr QListQSize where
  toQListQSizeConst (QListQSize ptr') = QListQSizeConst $ (HoppyF.castPtr :: HoppyF.Ptr QListQSize -> HoppyF.Ptr QListQSizeConst) ptr'
  toQListQSizeConst (QListQSizeGc fptr' ptr') = QListQSizeConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QListQSize -> HoppyF.Ptr QListQSizeConst) ptr'

instance QListQSizePtr QListQSize where
  toQListQSize = HoppyP.id

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

newCopy :: (QListQSizeValue arg'1) => (arg'1) -> (HoppyP.IO QListQSize)
newCopy arg'1 =
  withQListQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QListQSize
  (newCopy' arg'1')

class QListQSizeSuper a where
  downToQListQSize :: a -> QListQSize


class QListQSizeSuperConst a where
  downToQListQSizeConst :: a -> QListQSizeConst


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

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

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

instance HoppyFHR.Encodable QListQSize ([HSize.HSize]) where
  encode =
    QtahFHR.fromContents

instance HoppyFHR.Encodable QListQSizeConst ([HSize.HSize]) where
  encode = HoppyP.fmap (toQListQSizeConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QListQSize)

instance HoppyFHR.Decodable QListQSize ([HSize.HSize]) where
  decode = HoppyFHR.decode . toQListQSizeConst

instance HoppyFHR.Decodable QListQSizeConst ([HSize.HSize]) where
  decode =
    QtahFHR.toContents

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

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

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