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

module Graphics.UI.Qtah.Generated.Core.QVector.QString (
  QVectorQStringValue (..),
  QVectorQStringConstPtr (..),
  atConst,
  capacity,
  contains,
  count,
  arrayConst,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QVectorQStringPtr (..),
  append,
  appendVector,
  at,
  clear,
  array,
  fill,
  fillResize,
  first,
  insert,
  insertMany,
  last,
  prepend,
  remove,
  removeMany,
  removeAll,
  removeFirst,
  removeLast,
  removeOne,
  replace,
  reserve,
  resize,
  squeeze,
  swap,
  takeAt,
  takeFirst,
  takeLast,
  aSSIGN,
  QVectorQStringConst (..),
  castQVectorQStringToConst,
  QVectorQString (..),
  castQVectorQStringToNonconst,
  new,
  newWithSize,
  newWithSizeAndValue,
  newCopy,
  QVectorQStringSuper (..),
  QVectorQStringSuperConst (..),
  ) 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.Generated.Core.QString as M142
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QVectorQString_new" new' ::  HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_newWithSize" newWithSize' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_newWithSizeAndValue" newWithSizeAndValue' ::  HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_newCopy" newCopy' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_append" append' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_appendVector" appendVector' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr QVectorQStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_at" at' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QString)
foreign import ccall "genpop__QVectorQString_atConst" atConst' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_capacity" capacity' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_clear" clear' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_contains" contains' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQString_count" count' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_array" array' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO (HoppyF.Ptr M142.QString)
foreign import ccall "genpop__QVectorQString_arrayConst" arrayConst' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_endsWith" endsWith' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQString_fill" fill' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_fillResize" fillResize' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_first" first' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO (HoppyF.Ptr M142.QString)
foreign import ccall "genpop__QVectorQString_firstConst" firstConst' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_get" get' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_indexOf" indexOf' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_insert" insert' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_insertMany" insertMany' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_isEmpty" isEmpty' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQString_last" last' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO (HoppyF.Ptr M142.QString)
foreign import ccall "genpop__QVectorQString_lastConst" lastConst' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_mid" mid' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_midLength" midLength' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_prepend" prepend' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_remove" remove' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_removeMany" removeMany' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_removeAll" removeAll' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_removeFirst" removeFirst' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_removeLast" removeLast' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_removeOne" removeOne' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQString_replace" replace' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_reserve" reserve' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_resize" resize' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_size" size' ::  HoppyF.Ptr QVectorQStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQString_squeeze" squeeze' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_startsWith" startsWith' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQString_swap" swap' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr QVectorQString -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQString_takeAt" takeAt' ::  HoppyF.Ptr QVectorQString -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_takeFirst" takeFirst' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_takeLast" takeLast' ::  HoppyF.Ptr QVectorQString -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_value" value' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_valueOr" valueOr' ::  HoppyF.Ptr QVectorQStringConst -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVectorQString_ADD" aDD' ::  HoppyF.Ptr QVectorQStringConst -> HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "genpop__QVectorQString_ASSIGN" aSSIGN' ::  HoppyF.Ptr QVectorQString -> HoppyF.Ptr QVectorQStringConst -> HoppyP.IO (HoppyF.Ptr QVectorQString)
foreign import ccall "gendel__QVectorQString" delete'QVectorQString :: HoppyF.Ptr QVectorQStringConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVectorQString" deletePtr'QVectorQString :: HoppyF.FunPtr (HoppyF.Ptr QVectorQStringConst -> HoppyP.IO ())

class QVectorQStringValue a where
  withQVectorQStringPtr :: a -> (QVectorQStringConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVectorQStringConstPtr a => QVectorQStringValue a where
  withQVectorQStringPtr = HoppyP.flip ($) . toQVectorQStringConst

class (HoppyFHR.CppPtr this) => QVectorQStringConstPtr this where
  toQVectorQStringConst :: this -> QVectorQStringConst

atConst :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M142.QStringConst)
atConst arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M142.QStringConst
  (atConst' arg'1' arg'2')

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

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

count :: (QVectorQStringValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

arrayConst :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.IO M142.QStringConst)
arrayConst arg'1 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M142.QStringConst
  (arrayConst' arg'1')

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

firstConst :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.IO M142.QStringConst)
firstConst arg'1 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M142.QStringConst
  (firstConst' arg'1')

get :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
get arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QVectorQStringValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QVectorQStringValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr 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 :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isEmpty arg'1 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEmpty' arg'1')

lastConst :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.IO M142.QStringConst)
lastConst arg'1 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M142.QStringConst
  (lastConst' arg'1')

lastIndexOf :: (QVectorQStringValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QVectorQStringValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr 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 :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QVectorQString)
mid arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QVectorQString
  (mid' arg'1' arg'2')

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

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

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

value :: (QVectorQStringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
value arg'1 arg'2 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QVectorQStringValue this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QtahP.String)
valueOr arg'1 arg'2 arg'3 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

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

class (QVectorQStringConstPtr this) => QVectorQStringPtr this where
  toQVectorQString :: this -> QVectorQString

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

appendVector :: (QVectorQStringPtr this, QVectorQStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendVector arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  withQVectorQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendVector' arg'1' arg'2')

at :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M142.QString)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M142.QString
  (at' arg'1' arg'2')

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

array :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M142.QString)
array arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  HoppyP.fmap M142.QString
  (array' arg'1')

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

fillResize :: (QVectorQStringPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
fillResize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (fillResize' arg'1' arg'2' arg'3')

first :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M142.QString)
first arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  HoppyP.fmap M142.QString
  (first' arg'1')

insert :: (QVectorQStringPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

insertMany :: (QVectorQStringPtr this, M142.QStringValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
insertMany arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (insertMany' arg'1' arg'2' arg'3' arg'4')

last :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M142.QString)
last arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  HoppyP.fmap M142.QString
  (last' arg'1')

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

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

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

removeAll :: (QVectorQStringPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

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

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

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

replace :: (QVectorQStringPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

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

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

squeeze :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
squeeze arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (squeeze' arg'1')

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

takeAt :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (takeFirst' arg'1')

takeLast :: (QVectorQStringPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QVectorQStringPtr this, QVectorQStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVectorQString)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQString arg'1) $ \arg'1' ->
  withQVectorQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQString
  (aSSIGN' arg'1' arg'2')

data QVectorQStringConst =
    QVectorQStringConst (HoppyF.Ptr QVectorQStringConst)
  | QVectorQStringConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQStringConst)
  deriving (HoppyP.Show)

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

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

castQVectorQStringToConst :: QVectorQString -> QVectorQStringConst
castQVectorQStringToConst (QVectorQString ptr') = QVectorQStringConst $ HoppyF.castPtr ptr'
castQVectorQStringToConst (QVectorQStringGc fptr' ptr') = QVectorQStringConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVectorQStringConst QVectorQString where copy = newCopy

instance QVectorQStringConstPtr QVectorQStringConst where
  toQVectorQStringConst = HoppyP.id

data QVectorQString =
    QVectorQString (HoppyF.Ptr QVectorQString)
  | QVectorQStringGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQString)
  deriving (HoppyP.Show)

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

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

castQVectorQStringToNonconst :: QVectorQStringConst -> QVectorQString
castQVectorQStringToNonconst (QVectorQStringConst ptr') = QVectorQString $ HoppyF.castPtr ptr'
castQVectorQStringToNonconst (QVectorQStringConstGc fptr' ptr') = QVectorQStringGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVectorQString QVectorQString where copy = newCopy

instance QVectorQStringConstPtr QVectorQString where
  toQVectorQStringConst (QVectorQString ptr') = QVectorQStringConst $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQString -> HoppyF.Ptr QVectorQStringConst) ptr'
  toQVectorQStringConst (QVectorQStringGc fptr' ptr') = QVectorQStringConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQString -> HoppyF.Ptr QVectorQStringConst) ptr'

instance QVectorQStringPtr QVectorQString where
  toQVectorQString = HoppyP.id

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

newWithSize :: (HoppyP.Int) -> (HoppyP.IO QVectorQString)
newWithSize arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVectorQString
  (newWithSize' arg'1')

newWithSizeAndValue :: (M142.QStringValue arg'2) => (HoppyP.Int) -> (arg'2) -> (HoppyP.IO QVectorQString)
newWithSizeAndValue arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQString
  (newWithSizeAndValue' arg'1' arg'2')

newCopy :: (QVectorQStringValue arg'1) => (arg'1) -> (HoppyP.IO QVectorQString)
newCopy arg'1 =
  withQVectorQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVectorQString
  (newCopy' arg'1')

class QVectorQStringSuper a where
  downToQVectorQString :: a -> QVectorQString


class QVectorQStringSuperConst a where
  downToQVectorQStringConst :: a -> QVectorQStringConst


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

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

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

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

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

instance QtahFHR.FromContents QVectorQString (QtahP.String) where
  fromContents values' = do
    vector' <- new
    reserve vector' $ QtahFHR.coerceIntegral $ QtahP.length values'
    QtahP.mapM_ (append vector') values'
    QtahP.return vector'