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

module Graphics.UI.Qtah.Generated.Core.QList.QByteArray (
  QListQByteArrayValue (..),
  QListQByteArrayConstPtr (..),
  atConst,
  contains,
  count,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QListQByteArrayPtr (..),
  append,
  appendList,
  at,
  clear,
  first,
  insert,
  last,
  move,
  prepend,
  removeAll,
  removeAt,
  removeFirst,
  removeLast,
  removeOne,
  replace,
  reserve,
  swap,
  takeAt,
  takeFirst,
  takeLast,
  aSSIGN,
  QListQByteArrayConst (..),
  castQListQByteArrayToConst,
  QListQByteArray (..),
  castQListQByteArrayToNonconst,
  new,
  newCopy,
  QListQByteArraySuper (..),
  QListQByteArraySuperConst (..),
  ) where

import Control.Monad ((<=<))
import qualified Data.ByteString as QtahDBS
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.QByteArray as M12
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QListQByteArray_new" new' ::  HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "genpop__QListQByteArray_newCopy" newCopy' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "genpop__QListQByteArray_append" append' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_appendList" appendList' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_at" at' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArray)
foreign import ccall "genpop__QListQByteArray_atConst" atConst' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_clear" clear' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_contains" contains' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQByteArray_count" count' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_endsWith" endsWith' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQByteArray_first" first' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO (HoppyF.Ptr M12.QByteArray)
foreign import ccall "genpop__QListQByteArray_firstConst" firstConst' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_get" get' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_indexOf" indexOf' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_insert" insert' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_isEmpty" isEmpty' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQByteArray_last" last' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO (HoppyF.Ptr M12.QByteArray)
foreign import ccall "genpop__QListQByteArray_lastConst" lastConst' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_mid" mid' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "genpop__QListQByteArray_midLength" midLength' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "genpop__QListQByteArray_move" move' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_prepend" prepend' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_removeAll" removeAll' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_removeAt" removeAt' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_removeFirst" removeFirst' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_removeLast" removeLast' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_removeOne" removeOne' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQByteArray_replace" replace' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_reserve" reserve' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_size" size' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QListQByteArray_startsWith" startsWith' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QListQByteArray_swap" swap' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QListQByteArray_takeAt" takeAt' ::  HoppyF.Ptr QListQByteArray -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_takeFirst" takeFirst' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_takeLast" takeLast' ::  HoppyF.Ptr QListQByteArray -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_value" value' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_valueOr" valueOr' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyFC.CInt -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QListQByteArray_ADD" aDD' ::  HoppyF.Ptr QListQByteArrayConst -> HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "genpop__QListQByteArray_ASSIGN" aSSIGN' ::  HoppyF.Ptr QListQByteArray -> HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO (HoppyF.Ptr QListQByteArray)
foreign import ccall "gendel__QListQByteArray" delete'QListQByteArray :: HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO ()
foreign import ccall "&gendel__QListQByteArray" deletePtr'QListQByteArray :: HoppyF.FunPtr (HoppyF.Ptr QListQByteArrayConst -> HoppyP.IO ())

class QListQByteArrayValue a where
  withQListQByteArrayPtr :: a -> (QListQByteArrayConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QListQByteArrayConstPtr a => QListQByteArrayValue a where
  withQListQByteArrayPtr = HoppyP.flip ($) . toQListQByteArrayConst

instance {-# OVERLAPPING #-} QListQByteArrayValue ([QtahDBS.ByteString]) where
  withQListQByteArrayPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QListQByteArrayConstPtr this where
  toQListQByteArrayConst :: this -> QListQByteArrayConst

atConst :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M12.QByteArrayConst)
atConst arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M12.QByteArrayConst
  (atConst' arg'1' arg'2')

contains :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

count :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

endsWith :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWith arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWith' arg'1' arg'2')

firstConst :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArrayConst)
firstConst arg'1 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M12.QByteArrayConst
  (firstConst' arg'1')

get :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahDBS.ByteString)
get arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr 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 :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isEmpty arg'1 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEmpty' arg'1')

lastConst :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArrayConst)
lastConst arg'1 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M12.QByteArrayConst
  (lastConst' arg'1')

lastIndexOf :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr 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 :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QListQByteArray)
mid arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QListQByteArray
  (mid' arg'1' arg'2')

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

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

startsWith :: (QListQByteArrayValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWith arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWith' arg'1' arg'2')

value :: (QListQByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahDBS.ByteString)
value arg'1 arg'2 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QListQByteArrayValue this, M12.QByteArrayValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QtahDBS.ByteString)
valueOr arg'1 arg'2 arg'3 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M12.withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

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

class (QListQByteArrayConstPtr this) => QListQByteArrayPtr this where
  toQListQByteArray :: this -> QListQByteArray

append :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (append' arg'1' arg'2')

appendList :: (QListQByteArrayPtr this, QListQByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendList arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  withQListQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendList' arg'1' arg'2')

at :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M12.QByteArray)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M12.QByteArray
  (at' arg'1' arg'2')

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

first :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArray)
first arg'1 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  HoppyP.fmap M12.QByteArray
  (first' arg'1')

insert :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M12.withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

last :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArray)
last arg'1 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  HoppyP.fmap M12.QByteArray
  (last' arg'1')

move :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
move arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQByteArray 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 :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (prepend' arg'1' arg'2')

removeAll :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

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

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

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

removeOne :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removeOne arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removeOne' arg'1' arg'2')

replace :: (QListQByteArrayPtr this, M12.QByteArrayValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M12.withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

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

swap :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
swap arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQListQByteArray 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 :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahDBS.ByteString)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (takeFirst' arg'1')

takeLast :: (QListQByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QListQByteArrayPtr this, QListQByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QListQByteArray)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQListQByteArray arg'1) $ \arg'1' ->
  withQListQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QListQByteArray
  (aSSIGN' arg'1' arg'2')

data QListQByteArrayConst =
    QListQByteArrayConst (HoppyF.Ptr QListQByteArrayConst)
  | QListQByteArrayConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQByteArrayConst)
  deriving (HoppyP.Show)

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

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

castQListQByteArrayToConst :: QListQByteArray -> QListQByteArrayConst
castQListQByteArrayToConst (QListQByteArray ptr') = QListQByteArrayConst $ HoppyF.castPtr ptr'
castQListQByteArrayToConst (QListQByteArrayGc fptr' ptr') = QListQByteArrayConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQByteArrayConst QListQByteArray where copy = newCopy

instance QListQByteArrayConstPtr QListQByteArrayConst where
  toQListQByteArrayConst = HoppyP.id

data QListQByteArray =
    QListQByteArray (HoppyF.Ptr QListQByteArray)
  | QListQByteArrayGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QListQByteArray)
  deriving (HoppyP.Show)

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

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

castQListQByteArrayToNonconst :: QListQByteArrayConst -> QListQByteArray
castQListQByteArrayToNonconst (QListQByteArrayConst ptr') = QListQByteArray $ HoppyF.castPtr ptr'
castQListQByteArrayToNonconst (QListQByteArrayConstGc fptr' ptr') = QListQByteArrayGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QListQByteArray QListQByteArray where copy = newCopy

instance QListQByteArrayConstPtr QListQByteArray where
  toQListQByteArrayConst (QListQByteArray ptr') = QListQByteArrayConst $ (HoppyF.castPtr :: HoppyF.Ptr QListQByteArray -> HoppyF.Ptr QListQByteArrayConst) ptr'
  toQListQByteArrayConst (QListQByteArrayGc fptr' ptr') = QListQByteArrayConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QListQByteArray -> HoppyF.Ptr QListQByteArrayConst) ptr'

instance QListQByteArrayPtr QListQByteArray where
  toQListQByteArray = HoppyP.id

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

newCopy :: (QListQByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QListQByteArray)
newCopy arg'1 =
  withQListQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QListQByteArray
  (newCopy' arg'1')

class QListQByteArraySuper a where
  downToQListQByteArray :: a -> QListQByteArray


class QListQByteArraySuperConst a where
  downToQListQByteArrayConst :: a -> QListQByteArrayConst


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

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

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

instance HoppyFHR.Encodable QListQByteArray ([QtahDBS.ByteString]) where
  encode =
    QtahFHR.fromContents

instance HoppyFHR.Encodable QListQByteArrayConst ([QtahDBS.ByteString]) where
  encode = HoppyP.fmap (toQListQByteArrayConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QListQByteArray)

instance HoppyFHR.Decodable QListQByteArray ([QtahDBS.ByteString]) where
  decode = HoppyFHR.decode . toQListQByteArrayConst

instance HoppyFHR.Decodable QListQByteArrayConst ([QtahDBS.ByteString]) where
  decode =
    QtahFHR.toContents

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

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

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