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

module Graphics.UI.Qtah.Generated.Core.QVector.QLatin1String (
  QVectorQLatin1StringValue (..),
  QVectorQLatin1StringConstPtr (..),
  atConst,
  capacity,
  contains,
  count,
  arrayConst,
  endsWith,
  firstConst,
  get,
  indexOf,
  indexOfFrom,
  isEmpty,
  lastConst,
  lastIndexOf,
  lastIndexOfFrom,
  mid,
  midLength,
  size,
  startsWith,
  value,
  valueOr,
  aDD,
  QVectorQLatin1StringPtr (..),
  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,
  QVectorQLatin1StringConst (..),
  castQVectorQLatin1StringToConst,
  QVectorQLatin1String (..),
  castQVectorQLatin1StringToNonconst,
  new,
  newWithSize,
  newWithSizeAndValue,
  newCopy,
  QVectorQLatin1StringSuper (..),
  QVectorQLatin1StringSuperConst (..),
  ) 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.QLatin1String as M58
import Prelude (($), (-), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QVectorQLatin1String_new" new' ::  HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_newWithSize" newWithSize' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_newWithSizeAndValue" newWithSizeAndValue' ::  HoppyFC.CInt -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_newCopy" newCopy' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_append" append' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_appendVector" appendVector' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_at" at' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M58.QLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_atConst" atConst' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_capacity" capacity' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_clear" clear' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_contains" contains' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQLatin1String_count" count' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_array" array' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO (HoppyF.Ptr M58.QLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_arrayConst" arrayConst' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_endsWith" endsWith' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQLatin1String_fill" fill' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_fillResize" fillResize' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_first" first' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO (HoppyF.Ptr M58.QLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_firstConst" firstConst' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_get" get' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_indexOf" indexOf' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_insert" insert' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_insertMany" insertMany' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_isEmpty" isEmpty' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQLatin1String_last" last' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO (HoppyF.Ptr M58.QLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_lastConst" lastConst' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_mid" mid' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_midLength" midLength' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_prepend" prepend' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_remove" remove' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_removeMany" removeMany' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_removeAll" removeAll' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_removeFirst" removeFirst' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_removeLast" removeLast' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_removeOne" removeOne' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQLatin1String_replace" replace' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_reserve" reserve' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_resize" resize' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_size" size' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVectorQLatin1String_squeeze" squeeze' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_startsWith" startsWith' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVectorQLatin1String_swap" swap' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO ()
foreign import ccall "genpop__QVectorQLatin1String_takeAt" takeAt' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_takeFirst" takeFirst' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_takeLast" takeLast' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_value" value' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_valueOr" valueOr' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyFC.CInt -> HoppyF.Ptr M58.QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M58.QLatin1StringConst)
foreign import ccall "genpop__QVectorQLatin1String_ADD" aDD' ::  HoppyF.Ptr QVectorQLatin1StringConst -> HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "genpop__QVectorQLatin1String_ASSIGN" aSSIGN' ::  HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QVectorQLatin1String)
foreign import ccall "gendel__QVectorQLatin1String" delete'QVectorQLatin1String :: HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVectorQLatin1String" deletePtr'QVectorQLatin1String :: HoppyF.FunPtr (HoppyF.Ptr QVectorQLatin1StringConst -> HoppyP.IO ())

class QVectorQLatin1StringValue a where
  withQVectorQLatin1StringPtr :: a -> (QVectorQLatin1StringConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVectorQLatin1StringConstPtr a => QVectorQLatin1StringValue a where
  withQVectorQLatin1StringPtr = HoppyP.flip ($) . toQVectorQLatin1StringConst

class (HoppyFHR.CppPtr this) => QVectorQLatin1StringConstPtr this where
  toQVectorQLatin1StringConst :: this -> QVectorQLatin1StringConst

atConst :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M58.QLatin1StringConst)
atConst arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M58.QLatin1StringConst
  (atConst' arg'1' arg'2')

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

contains :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

count :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
count arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (count' arg'1' arg'2')

arrayConst :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1StringConst)
arrayConst arg'1 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M58.QLatin1StringConst
  (arrayConst' arg'1')

endsWith :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWith arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWith' arg'1' arg'2')

firstConst :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1StringConst)
firstConst arg'1 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M58.QLatin1StringConst
  (firstConst' arg'1')

get :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M58.QLatin1String)
get arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (get' arg'1' arg'2')

indexOf :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

indexOfFrom :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr 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 :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isEmpty arg'1 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEmpty' arg'1')

lastConst :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1StringConst)
lastConst arg'1 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M58.QLatin1StringConst
  (lastConst' arg'1')

lastIndexOf :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
lastIndexOf arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOf' arg'1' arg'2')

lastIndexOfFrom :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfFrom arg'1 arg'2 arg'3 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr 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 :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QVectorQLatin1String)
mid arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap QVectorQLatin1String
  (mid' arg'1' arg'2')

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

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

startsWith :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWith arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWith' arg'1' arg'2')

value :: (QVectorQLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M58.QLatin1String)
value arg'1 arg'2 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (value' arg'1' arg'2')

valueOr :: (QVectorQLatin1StringValue this, M58.QLatin1StringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO M58.QLatin1String)
valueOr arg'1 arg'2 arg'3 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M58.withQLatin1StringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (valueOr' arg'1' arg'2' arg'3')

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

class (QVectorQLatin1StringConstPtr this) => QVectorQLatin1StringPtr this where
  toQVectorQLatin1String :: this -> QVectorQLatin1String

append :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (append' arg'1' arg'2')

appendVector :: (QVectorQLatin1StringPtr this, QVectorQLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendVector arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  withQVectorQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendVector' arg'1' arg'2')

at :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M58.QLatin1String)
at arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M58.QLatin1String
  (at' arg'1' arg'2')

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

array :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1String)
array arg'1 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  HoppyP.fmap M58.QLatin1String
  (array' arg'1')

fill :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
fill arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (fill' arg'1' arg'2')

fillResize :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
fillResize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (fillResize' arg'1' arg'2' arg'3')

first :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1String)
first arg'1 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  HoppyP.fmap M58.QLatin1String
  (first' arg'1')

insert :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insert arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M58.withQLatin1StringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insert' arg'1' arg'2' arg'3')

insertMany :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
insertMany arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M58.withQLatin1StringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (insertMany' arg'1' arg'2' arg'3' arg'4')

last :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1String)
last arg'1 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  HoppyP.fmap M58.QLatin1String
  (last' arg'1')

prepend :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (prepend' arg'1' arg'2')

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

removeMany :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
removeMany arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String 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 :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
removeAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (removeAll' arg'1' arg'2')

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

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

removeOne :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removeOne arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removeOne' arg'1' arg'2')

replace :: (QVectorQLatin1StringPtr this, M58.QLatin1StringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
replace arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M58.withQLatin1StringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (replace' arg'1' arg'2' arg'3')

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

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

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

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

takeAt :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M58.QLatin1String)
takeAt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (takeAt' arg'1' arg'2')

takeFirst :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1String)
takeFirst arg'1 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (takeFirst' arg'1')

takeLast :: (QVectorQLatin1StringPtr this) => (this) {- ^ this -} -> (HoppyP.IO M58.QLatin1String)
takeLast arg'1 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M58.QLatin1StringConst) =<<
  (takeLast' arg'1')

aSSIGN :: (QVectorQLatin1StringPtr this, QVectorQLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVectorQLatin1String)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVectorQLatin1String arg'1) $ \arg'1' ->
  withQVectorQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQLatin1String
  (aSSIGN' arg'1' arg'2')

data QVectorQLatin1StringConst =
    QVectorQLatin1StringConst (HoppyF.Ptr QVectorQLatin1StringConst)
  | QVectorQLatin1StringConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQLatin1StringConst)
  deriving (HoppyP.Show)

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

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

castQVectorQLatin1StringToConst :: QVectorQLatin1String -> QVectorQLatin1StringConst
castQVectorQLatin1StringToConst (QVectorQLatin1String ptr') = QVectorQLatin1StringConst $ HoppyF.castPtr ptr'
castQVectorQLatin1StringToConst (QVectorQLatin1StringGc fptr' ptr') = QVectorQLatin1StringConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVectorQLatin1StringConst QVectorQLatin1String where copy = newCopy

instance QVectorQLatin1StringConstPtr QVectorQLatin1StringConst where
  toQVectorQLatin1StringConst = HoppyP.id

data QVectorQLatin1String =
    QVectorQLatin1String (HoppyF.Ptr QVectorQLatin1String)
  | QVectorQLatin1StringGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVectorQLatin1String)
  deriving (HoppyP.Show)

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

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

castQVectorQLatin1StringToNonconst :: QVectorQLatin1StringConst -> QVectorQLatin1String
castQVectorQLatin1StringToNonconst (QVectorQLatin1StringConst ptr') = QVectorQLatin1String $ HoppyF.castPtr ptr'
castQVectorQLatin1StringToNonconst (QVectorQLatin1StringConstGc fptr' ptr') = QVectorQLatin1StringGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QVectorQLatin1String QVectorQLatin1String where copy = newCopy

instance QVectorQLatin1StringConstPtr QVectorQLatin1String where
  toQVectorQLatin1StringConst (QVectorQLatin1String ptr') = QVectorQLatin1StringConst $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr QVectorQLatin1StringConst) ptr'
  toQVectorQLatin1StringConst (QVectorQLatin1StringGc fptr' ptr') = QVectorQLatin1StringConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVectorQLatin1String -> HoppyF.Ptr QVectorQLatin1StringConst) ptr'

instance QVectorQLatin1StringPtr QVectorQLatin1String where
  toQVectorQLatin1String = HoppyP.id

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

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

newWithSizeAndValue :: (M58.QLatin1StringValue arg'2) => (HoppyP.Int) -> (arg'2) -> (HoppyP.IO QVectorQLatin1String)
newWithSizeAndValue arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  M58.withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVectorQLatin1String
  (newWithSizeAndValue' arg'1' arg'2')

newCopy :: (QVectorQLatin1StringValue arg'1) => (arg'1) -> (HoppyP.IO QVectorQLatin1String)
newCopy arg'1 =
  withQVectorQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVectorQLatin1String
  (newCopy' arg'1')

class QVectorQLatin1StringSuper a where
  downToQVectorQLatin1String :: a -> QVectorQLatin1String


class QVectorQLatin1StringSuperConst a where
  downToQVectorQLatin1StringConst :: a -> QVectorQLatin1StringConst


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

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

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

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

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

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