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

module Graphics.UI.Qtah.Generated.Core.QByteArray (
  QByteArrayValue (..),
  QByteArrayConstPtr (..),
  indexOf,
  indexOfFrom,
  indexOfPtrConstChar,
  indexOfPtrConstCharFrom,
  indexOfChar,
  indexOfCharFrom,
  indexOfString,
  indexOfStringFrom,
  lastIndexOf,
  lastIndexOfFrom,
  lastIndexOfPtrConstChar,
  lastIndexOfPtrConstCharFrom,
  lastIndexOfChar,
  lastIndexOfCharFrom,
  lastIndexOfString,
  lastIndexOfStringFrom,
  at,
  back,
  capacity,
  chopped,
  comparePtrConstChar,
  comparePtrConstCharWithCase,
  compare,
  compareWithCase,
  constData,
  contains,
  containsPtrConstChar,
  containsChar,
  countByteArray,
  countPtrConstChar,
  countChar,
  count,
  getDataConst,
  endsWith,
  endsWithPtrConstChar,
  endsWithChar,
  front,
  isEmpty,
  isLower,
  isNull,
  isUpper,
  left,
  leftJustified,
  leftJustifiedWithChar,
  leftJustifiedWithCharAndTruncate,
  length,
  size,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QByteArrayPtr (..),
  append,
  appendCountAndChar,
  appendPtrConstChar,
  appendPtrConstCharAndSize,
  appendChar,
  appendString,
  insert,
  insertCountAndChar,
  insertPtrConstChar,
  insertPtrConstCharAndSize,
  insertChar,
  insertString,
  prepend,
  prependCountAndChar,
  prependPtrConstChar,
  prependPtrConstCharAndSize,
  prependChar,
  replaceRangeWithByteArray,
  replaceRangeWithPtrConstCharAndSize,
  replaceRangeWithPtrConstChar,
  replaceCharWithPtrConstChar,
  replaceCharWithByteArray,
  replacePtrConstChar,
  replacePtrConstCharAndSize,
  replaceByteArray,
  replaceByteArrayWithPtrConstChar,
  replacePtrConstCharWithByteArray,
  replaceChar,
  replaceStringWithPtrConstChar,
  replaceCharWithString,
  replaceStringWithByteArray,
  setNumInt,
  setNumIntWithBase,
  setNumUshort,
  setNumUshortWithBase,
  setNumShort,
  setNumShortWithBase,
  setNumUint,
  setNumUintWithBase,
  setNumFloat,
  setNumFloatWithFormat,
  setNumFloatWithFormatAndPrecision,
  setNumDouble,
  setNumDoubleWithFormat,
  setNumDoubleWithFormatAndPrecision,
  chop,
  clear,
  getData,
  fill,
  fillWithSize,
  aSSIGN,
  QByteArrayConst (..),
  castQByteArrayToConst,
  QByteArray (..),
  castQByteArrayToNonconst,
  new,
  newFromData,
  newFromDataAndSize,
  newFromRepeatedChar,
  newCopy,
  QByteArraySuper (..),
  QByteArraySuperConst (..),
  QByteArrayBase64Option (..),
  QByteArrayBase64Options,
  IsQByteArrayBase64Options (..),
  base64Encoding,
  base64UrlEncoding,
  keepTrailingEquals,
  omitTrailingEquals,
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Data.ByteString as QtahDBS
import qualified Data.ByteString.Unsafe as QtahDBSU
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.Flags as QtahFlags
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QByteArray_new" new' ::  HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_newFromData" newFromData' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_newFromDataAndSize" newFromDataAndSize' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_newFromRepeatedChar" newFromRepeatedChar' ::  HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_newCopy" newCopy' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_append" append' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_appendCountAndChar" appendCountAndChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_appendPtrConstChar" appendPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_appendPtrConstCharAndSize" appendPtrConstCharAndSize' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_appendChar" appendChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_appendString" appendString' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insert" insert' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insertCountAndChar" insertCountAndChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insertPtrConstChar" insertPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insertPtrConstCharAndSize" insertPtrConstCharAndSize' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insertChar" insertChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_insertString" insertString' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_prepend" prepend' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_prependCountAndChar" prependCountAndChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_prependPtrConstChar" prependPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_prependPtrConstCharAndSize" prependPtrConstCharAndSize' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_prependChar" prependChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceRangeWithByteArray" replaceRangeWithByteArray' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceRangeWithPtrConstCharAndSize" replaceRangeWithPtrConstCharAndSize' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceRangeWithPtrConstChar" replaceRangeWithPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceCharWithPtrConstChar" replaceCharWithPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceCharWithByteArray" replaceCharWithByteArray' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replacePtrConstChar" replacePtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replacePtrConstCharAndSize" replacePtrConstCharAndSize' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceByteArray" replaceByteArray' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceByteArrayWithPtrConstChar" replaceByteArrayWithPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replacePtrConstCharWithByteArray" replacePtrConstCharWithByteArray' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceChar" replaceChar' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceStringWithPtrConstChar" replaceStringWithPtrConstChar' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceCharWithString" replaceCharWithString' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_replaceStringWithByteArray" replaceStringWithByteArray' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_indexOf" indexOf' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfFrom" indexOfFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfPtrConstChar" indexOfPtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfPtrConstCharFrom" indexOfPtrConstCharFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfChar" indexOfChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfCharFrom" indexOfCharFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfString" indexOfString' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_indexOfStringFrom" indexOfStringFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOf" lastIndexOf' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfFrom" lastIndexOfFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfPtrConstChar" lastIndexOfPtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfPtrConstCharFrom" lastIndexOfPtrConstCharFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfChar" lastIndexOfChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfCharFrom" lastIndexOfCharFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfString" lastIndexOfString' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_lastIndexOfStringFrom" lastIndexOfStringFrom' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_setNumInt" setNumInt' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumIntWithBase" setNumIntWithBase' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumUshort" setNumUshort' ::  HoppyF.Ptr QByteArray -> HoppyFC.CUShort -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumUshortWithBase" setNumUshortWithBase' ::  HoppyF.Ptr QByteArray -> HoppyFC.CUShort -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumShort" setNumShort' ::  HoppyF.Ptr QByteArray -> HoppyFC.CShort -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumShortWithBase" setNumShortWithBase' ::  HoppyF.Ptr QByteArray -> HoppyFC.CShort -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumUint" setNumUint' ::  HoppyF.Ptr QByteArray -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumUintWithBase" setNumUintWithBase' ::  HoppyF.Ptr QByteArray -> HoppyFC.CUInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumFloat" setNumFloat' ::  HoppyF.Ptr QByteArray -> HoppyFC.CFloat -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumFloatWithFormat" setNumFloatWithFormat' ::  HoppyF.Ptr QByteArray -> HoppyFC.CFloat -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumFloatWithFormatAndPrecision" setNumFloatWithFormatAndPrecision' ::  HoppyF.Ptr QByteArray -> HoppyFC.CFloat -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumDouble" setNumDouble' ::  HoppyF.Ptr QByteArray -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumDoubleWithFormat" setNumDoubleWithFormat' ::  HoppyF.Ptr QByteArray -> HoppyFC.CDouble -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_setNumDoubleWithFormatAndPrecision" setNumDoubleWithFormatAndPrecision' ::  HoppyF.Ptr QByteArray -> HoppyFC.CDouble -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_at" at' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CChar
foreign import ccall "genpop__QByteArray_back" back' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CChar
foreign import ccall "genpop__QByteArray_capacity" capacity' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_chop" chop' ::  HoppyF.Ptr QByteArray -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QByteArray_chopped" chopped' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArrayConst)
foreign import ccall "genpop__QByteArray_comparePtrConstChar" comparePtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_comparePtrConstCharWithCase" comparePtrConstCharWithCase' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_compare" compare' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_compareWithCase" compareWithCase' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_constData" constData' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QByteArray_contains" contains' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_containsPtrConstChar" containsPtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_containsChar" containsChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_countByteArray" countByteArray' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_countPtrConstChar" countPtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_countChar" countChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_count" count' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_clear" clear' ::  HoppyF.Ptr QByteArray -> HoppyP.IO ()
foreign import ccall "genpop__QByteArray_getData" getData' ::  HoppyF.Ptr QByteArray -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QByteArray_getDataConst" getDataConst' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QByteArray_endsWith" endsWith' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_endsWithPtrConstChar" endsWithPtrConstChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_endsWithChar" endsWithChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_fill" fill' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_fillWithSize" fillWithSize' ::  HoppyF.Ptr QByteArray -> HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "genpop__QByteArray_front" front' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CChar
foreign import ccall "genpop__QByteArray_isEmpty" isEmpty' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_isLower" isLower' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_isNull" isNull' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_isUpper" isUpper' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_left" left' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArrayConst)
foreign import ccall "genpop__QByteArray_leftJustified" leftJustified' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QByteArrayConst)
foreign import ccall "genpop__QByteArray_leftJustifiedWithChar" leftJustifiedWithChar' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QByteArrayConst)
foreign import ccall "genpop__QByteArray_leftJustifiedWithCharAndTruncate" leftJustifiedWithCharAndTruncate' ::  HoppyF.Ptr QByteArrayConst -> HoppyFC.CInt -> HoppyFC.CChar -> HoppyFC.CBool -> HoppyP.IO (HoppyF.Ptr QByteArrayConst)
foreign import ccall "genpop__QByteArray_length" length' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_size" size' ::  HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QByteArray_EQ" eQ' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_NE" nE' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_LT" lT' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_LE" lE' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_GT" gT' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_GE" gE' ::  HoppyF.Ptr QByteArrayConst -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QByteArray_ASSIGN" aSSIGN' ::  HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QByteArray)
foreign import ccall "gendel__QByteArray" delete'QByteArray :: HoppyF.Ptr QByteArrayConst -> HoppyP.IO ()
foreign import ccall "&gendel__QByteArray" deletePtr'QByteArray :: HoppyF.FunPtr (HoppyF.Ptr QByteArrayConst -> HoppyP.IO ())

class QByteArrayValue a where
  withQByteArrayPtr :: a -> (QByteArrayConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QByteArrayConstPtr a => QByteArrayValue a where
  withQByteArrayPtr = HoppyP.flip ($) . toQByteArrayConst

instance {-# OVERLAPPING #-} QByteArrayValue (QtahDBS.ByteString) where
  withQByteArrayPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QByteArrayConstPtr this where
  toQByteArrayConst :: this -> QByteArrayConst

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

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

indexOfPtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
indexOfPtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfPtrConstChar' arg'1' arg'2')

indexOfPtrConstCharFrom :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfPtrConstCharFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfPtrConstCharFrom' arg'1' arg'2' arg'3')

indexOfChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
indexOfChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfChar' arg'1' arg'2')

indexOfCharFrom :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfCharFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfCharFrom' arg'1' arg'2' arg'3')

indexOfString :: (QByteArrayValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfString arg'1 arg'2 arg'3 =
  withQByteArrayPtr 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
  ) =<<
  (indexOfString' arg'1' arg'2' arg'3')

indexOfStringFrom :: (QByteArrayValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
indexOfStringFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr 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
  ) =<<
  (indexOfStringFrom' arg'1' arg'2' arg'3')

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

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

lastIndexOfPtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
lastIndexOfPtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfPtrConstChar' arg'1' arg'2')

lastIndexOfPtrConstCharFrom :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfPtrConstCharFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfPtrConstCharFrom' arg'1' arg'2' arg'3')

lastIndexOfChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
lastIndexOfChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfChar' arg'1' arg'2')

lastIndexOfCharFrom :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfCharFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (lastIndexOfCharFrom' arg'1' arg'2' arg'3')

lastIndexOfString :: (QByteArrayValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfString arg'1 arg'2 arg'3 =
  withQByteArrayPtr 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
  ) =<<
  (lastIndexOfString' arg'1' arg'2' arg'3')

lastIndexOfStringFrom :: (QByteArrayValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
lastIndexOfStringFrom arg'1 arg'2 arg'3 =
  withQByteArrayPtr 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
  ) =<<
  (lastIndexOfStringFrom' arg'1' arg'2' arg'3')

at :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CChar)
at arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (at' arg'1' arg'2')

back :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CChar)
back arg'1 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (back' arg'1')

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

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

comparePtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
comparePtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (comparePtrConstChar' arg'1' arg'2')

comparePtrConstCharWithCase :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Int)
comparePtrConstCharWithCase arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (comparePtrConstCharWithCase' arg'1' arg'2' arg'3')

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

compareWithCase :: (QByteArrayValue this, QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Int)
compareWithCase arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (compareWithCase' arg'1' arg'2' arg'3')

constData :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
constData arg'1 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (constData' arg'1')

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

containsPtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Bool)
containsPtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (containsPtrConstChar' arg'1' arg'2')

containsChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Bool)
containsChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (containsChar' arg'1' arg'2')

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

countPtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
countPtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (countPtrConstChar' arg'1' arg'2')

countChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Int)
countChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (countChar' arg'1' arg'2')

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

getDataConst :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
getDataConst arg'1 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (getDataConst' arg'1')

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

endsWithPtrConstChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO HoppyP.Bool)
endsWithPtrConstChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWithPtrConstChar' arg'1' arg'2')

endsWithChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO HoppyP.Bool)
endsWithChar arg'1 arg'2 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWithChar' arg'1' arg'2')

front :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CChar)
front arg'1 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (front' arg'1')

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

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

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

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

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

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

leftJustifiedWithChar :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QtahDBS.ByteString)
leftJustifiedWithChar arg'1 arg'2 arg'3 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (HoppyFHR.decodeAndDelete . QByteArrayConst) =<<
  (leftJustifiedWithChar' arg'1' arg'2' arg'3')

leftJustifiedWithCharAndTruncate :: (QByteArrayValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.Bool) -> (HoppyP.IO QtahDBS.ByteString)
leftJustifiedWithCharAndTruncate arg'1 arg'2 arg'3 arg'4 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QByteArrayConst) =<<
  (leftJustifiedWithCharAndTruncate' arg'1' arg'2' arg'3' arg'4')

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

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

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

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

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

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

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

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

class (QByteArrayConstPtr this) => QByteArrayPtr this where
  toQByteArray :: this -> QByteArray

append :: (QByteArrayPtr this, QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QByteArray)
append arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QByteArray
  (append' arg'1' arg'2')

appendCountAndChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
appendCountAndChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (appendCountAndChar' arg'1' arg'2' arg'3')

appendPtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
appendPtrConstChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (appendPtrConstChar' arg'1' arg'2')

appendPtrConstCharAndSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
appendPtrConstCharAndSize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (appendPtrConstCharAndSize' arg'1' arg'2' arg'3')

appendChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
appendChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (appendChar' arg'1' arg'2')

appendString :: (QByteArrayPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QByteArray)
appendString arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QByteArray
  (appendString' arg'1' arg'2')

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

insertCountAndChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
insertCountAndChar arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  HoppyP.fmap QByteArray
  (insertCountAndChar' arg'1' arg'2' arg'3' arg'4')

insertPtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
insertPtrConstChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (insertPtrConstChar' arg'1' arg'2' arg'3')

insertPtrConstCharAndSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
insertPtrConstCharAndSize arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QByteArray
  (insertPtrConstCharAndSize' arg'1' arg'2' arg'3' arg'4')

insertChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
insertChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (insertChar' arg'1' arg'2' arg'3')

insertString :: (QByteArrayPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QByteArray)
insertString arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (insertString' arg'1' arg'2' arg'3')

prepend :: (QByteArrayPtr this, QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QByteArray)
prepend arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QByteArray
  (prepend' arg'1' arg'2')

prependCountAndChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
prependCountAndChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (prependCountAndChar' arg'1' arg'2' arg'3')

prependPtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
prependPtrConstChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (prependPtrConstChar' arg'1' arg'2')

prependPtrConstCharAndSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
prependPtrConstCharAndSize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (prependPtrConstCharAndSize' arg'1' arg'2' arg'3')

prependChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
prependChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (prependChar' arg'1' arg'2')

replaceRangeWithByteArray :: (QByteArrayPtr this, QByteArrayValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO QByteArray)
replaceRangeWithByteArray arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  withQByteArrayPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap QByteArray
  (replaceRangeWithByteArray' arg'1' arg'2' arg'3' arg'4')

replaceRangeWithPtrConstCharAndSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
replaceRangeWithPtrConstCharAndSize arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  HoppyP.fmap QByteArray
  (replaceRangeWithPtrConstCharAndSize' arg'1' arg'2' arg'3' arg'4' arg'5')

replaceRangeWithPtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replaceRangeWithPtrConstChar arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  HoppyP.fmap QByteArray
  (replaceRangeWithPtrConstChar' arg'1' arg'2' arg'3' arg'4')

replaceCharWithPtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replaceCharWithPtrConstChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (replaceCharWithPtrConstChar' arg'1' arg'2' arg'3')

replaceCharWithByteArray :: (QByteArrayPtr this, QByteArrayValue arg'3) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (arg'3) -> (HoppyP.IO QByteArray)
replaceCharWithByteArray arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (replaceCharWithByteArray' arg'1' arg'2' arg'3')

replacePtrConstChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replacePtrConstChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (replacePtrConstChar' arg'1' arg'2' arg'3')

replacePtrConstCharAndSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
replacePtrConstCharAndSize arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  HoppyP.fmap QByteArray
  (replacePtrConstCharAndSize' arg'1' arg'2' arg'3' arg'4' arg'5')

replaceByteArray :: (QByteArrayPtr this, QByteArrayValue arg'2, QByteArrayValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO QByteArray)
replaceByteArray arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (replaceByteArray' arg'1' arg'2' arg'3')

replaceByteArrayWithPtrConstChar :: (QByteArrayPtr this, QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replaceByteArrayWithPtrConstChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (replaceByteArrayWithPtrConstChar' arg'1' arg'2' arg'3')

replacePtrConstCharWithByteArray :: (QByteArrayPtr this, QByteArrayValue arg'3) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (arg'3) -> (HoppyP.IO QByteArray)
replacePtrConstCharWithByteArray arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (replacePtrConstCharWithByteArray' arg'1' arg'2' arg'3')

replaceChar :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replaceChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (replaceChar' arg'1' arg'2' arg'3')

replaceStringWithPtrConstChar :: (QByteArrayPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
replaceStringWithPtrConstChar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (replaceStringWithPtrConstChar' arg'1' arg'2' arg'3')

replaceCharWithString :: (QByteArrayPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (arg'3) -> (HoppyP.IO QByteArray)
replaceCharWithString arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (replaceCharWithString' arg'1' arg'2' arg'3')

replaceStringWithByteArray :: (QByteArrayPtr this, M142.QStringValue arg'2, QByteArrayValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO QByteArray)
replaceStringWithByteArray arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QByteArray
  (replaceStringWithByteArray' arg'1' arg'2' arg'3')

setNumInt :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumInt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QByteArray
  (setNumInt' arg'1' arg'2')

setNumIntWithBase :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumIntWithBase arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (setNumIntWithBase' arg'1' arg'2' arg'3')

setNumUshort :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.IO QByteArray)
setNumUshort arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (setNumUshort' arg'1' arg'2')

setNumUshortWithBase :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CUShort) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumUshortWithBase arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (setNumUshortWithBase' arg'1' arg'2' arg'3')

setNumShort :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.IO QByteArray)
setNumShort arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (setNumShort' arg'1' arg'2')

setNumShortWithBase :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CShort) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumShortWithBase arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (setNumShortWithBase' arg'1' arg'2' arg'3')

setNumUint :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO QByteArray)
setNumUint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (setNumUint' arg'1' arg'2')

setNumUintWithBase :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumUintWithBase arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (setNumUintWithBase' arg'1' arg'2' arg'3')

setNumFloat :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Float) -> (HoppyP.IO QByteArray)
setNumFloat arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QByteArray
  (setNumFloat' arg'1' arg'2')

setNumFloatWithFormat :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Float) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
setNumFloatWithFormat arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (setNumFloatWithFormat' arg'1' arg'2' arg'3')

setNumFloatWithFormatAndPrecision :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Float) -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumFloatWithFormatAndPrecision arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QByteArray
  (setNumFloatWithFormatAndPrecision' arg'1' arg'2' arg'3' arg'4')

setNumDouble :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO QByteArray)
setNumDouble arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QByteArray
  (setNumDouble' arg'1' arg'2')

setNumDoubleWithFormat :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
setNumDoubleWithFormat arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  HoppyP.fmap QByteArray
  (setNumDoubleWithFormat' arg'1' arg'2' arg'3')

setNumDoubleWithFormatAndPrecision :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
setNumDoubleWithFormatAndPrecision arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QByteArray
  (setNumDoubleWithFormatAndPrecision' arg'1' arg'2' arg'3' arg'4')

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

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

getData :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
getData arg'1 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  (getData' arg'1')

fill :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
fill arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (fill' arg'1' arg'2')

fillWithSize :: (QByteArrayPtr this) => (this) {- ^ this -} -> (HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
fillWithSize arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QByteArray
  (fillWithSize' arg'1' arg'2' arg'3')

aSSIGN :: (QByteArrayPtr this, QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QByteArray)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQByteArray arg'1) $ \arg'1' ->
  withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QByteArray
  (aSSIGN' arg'1' arg'2')

data QByteArrayConst =
    QByteArrayConst (HoppyF.Ptr QByteArrayConst)
  | QByteArrayConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QByteArrayConst)
  deriving (HoppyP.Show)

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

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

castQByteArrayToConst :: QByteArray -> QByteArrayConst
castQByteArrayToConst (QByteArray ptr') = QByteArrayConst $ HoppyF.castPtr ptr'
castQByteArrayToConst (QByteArrayGc fptr' ptr') = QByteArrayConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QByteArrayConst QByteArray where copy = newCopy

instance QByteArrayConstPtr QByteArrayConst where
  toQByteArrayConst = HoppyP.id

data QByteArray =
    QByteArray (HoppyF.Ptr QByteArray)
  | QByteArrayGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QByteArray)
  deriving (HoppyP.Show)

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

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

castQByteArrayToNonconst :: QByteArrayConst -> QByteArray
castQByteArrayToNonconst (QByteArrayConst ptr') = QByteArray $ HoppyF.castPtr ptr'
castQByteArrayToNonconst (QByteArrayConstGc fptr' ptr') = QByteArrayGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QByteArray QByteArray where copy = newCopy

instance QByteArrayConstPtr QByteArray where
  toQByteArrayConst (QByteArray ptr') = QByteArrayConst $ (HoppyF.castPtr :: HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst) ptr'
  toQByteArrayConst (QByteArrayGc fptr' ptr') = QByteArrayConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QByteArray -> HoppyF.Ptr QByteArrayConst) ptr'

instance QByteArrayPtr QByteArray where
  toQByteArray = HoppyP.id

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

newFromData :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QByteArray)
newFromData arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QByteArray
  (newFromData' arg'1')

newFromDataAndSize :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QByteArray)
newFromDataAndSize arg'1 arg'2 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QByteArray
  (newFromDataAndSize' arg'1' arg'2')

newFromRepeatedChar :: (HoppyP.Int) -> (HoppyFC.CChar) -> (HoppyP.IO QByteArray)
newFromRepeatedChar arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QByteArray
  (newFromRepeatedChar' arg'1' arg'2')

newCopy :: (QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QByteArray)
newCopy arg'1 =
  withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QByteArray
  (newCopy' arg'1')

class QByteArraySuper a where
  downToQByteArray :: a -> QByteArray


class QByteArraySuperConst a where
  downToQByteArrayConst :: a -> QByteArrayConst


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

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

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

instance HoppyFHR.Encodable QByteArray (QtahDBS.ByteString) where
  encode =
    convertToCpp

instance HoppyFHR.Encodable QByteArrayConst (QtahDBS.ByteString) where
  encode = HoppyP.fmap (toQByteArrayConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QByteArray)

instance HoppyFHR.Decodable QByteArray (QtahDBS.ByteString) where
  decode = HoppyFHR.decode . toQByteArrayConst

instance HoppyFHR.Decodable QByteArrayConst (QtahDBS.ByteString) where
  decode =
    convertFromCpp

convertToCpp :: QtahDBS.ByteString -> QtahP.IO QByteArray
convertToCpp =
  QtahP.flip QtahDBSU.unsafeUseAsCStringLen $ QtahP.uncurry newFromDataAndSize

convertFromCpp :: QByteArrayValue ba => ba -> QtahP.IO QtahDBS.ByteString
convertFromCpp ba = do
  d <- getDataConst ba
  len <- size ba
  QtahDBS.packCStringLen (d, len)

data QByteArrayBase64Option =
  Base64Encoding
  | KeepTrailingEquals
  | Base64UrlEncoding
  | OmitTrailingEquals
  | UnknownQByteArrayBase64Option (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QByteArrayBase64Option where
  fromCppEnum Base64Encoding = 0
  fromCppEnum KeepTrailingEquals = 0
  fromCppEnum Base64UrlEncoding = 1
  fromCppEnum OmitTrailingEquals = 2
  fromCppEnum (UnknownQByteArrayBase64Option n) = n
  
  toCppEnum (0) = KeepTrailingEquals
  toCppEnum (1) = Base64UrlEncoding
  toCppEnum (2) = OmitTrailingEquals
  toCppEnum n = UnknownQByteArrayBase64Option n

instance HoppyP.Eq QByteArrayBase64Option where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QByteArrayBase64Option where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

newtype QByteArrayBase64Options = QByteArrayBase64Options (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QByteArrayBase64Option QByteArrayBase64Options where
  enumToFlags = QByteArrayBase64Options . QtahFHR.fromCppEnum
  flagsToEnum (QByteArrayBase64Options x') = QtahFHR.toCppEnum x'

class IsQByteArrayBase64Options a where
  toQByteArrayBase64Options :: a -> QByteArrayBase64Options

instance IsQByteArrayBase64Options QByteArrayBase64Options where toQByteArrayBase64Options = QtahP.id
instance IsQByteArrayBase64Options QByteArrayBase64Option where toQByteArrayBase64Options = QtahFlags.enumToFlags
instance IsQByteArrayBase64Options (HoppyFC.CInt) where toQByteArrayBase64Options = QtahFlags.numToFlags

base64Encoding :: QByteArrayBase64Options
base64Encoding = QByteArrayBase64Options (0)

base64UrlEncoding :: QByteArrayBase64Options
base64UrlEncoding = QByteArrayBase64Options (1)

keepTrailingEquals :: QByteArrayBase64Options
keepTrailingEquals = QByteArrayBase64Options (0)

omitTrailingEquals :: QByteArrayBase64Options
omitTrailingEquals = QByteArrayBase64Options (2)

instance QtahDB.Bits QByteArrayBase64Options where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum