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

module Graphics.UI.Qtah.Generated.Core.QLatin1String (
  QLatin1StringValue (..),
  QLatin1StringConstPtr (..),
  at,
  back,
  chopped,
  dataString,
  front,
  isEmpty,
  isNull,
  latin1,
  left,
  mid,
  midWithLength,
  right,
  size,
  trimmed,
  endsWithLatin1String,
  endsWithLatin1StringWithCase,
  endsWithChar,
  endsWithCharWithCase,
  startsWithLatin1String,
  startsWithLatin1StringWithCase,
  startsWithCharWith,
  startsWithCharWithCase,
  nEString,
  nEPtrConstChar,
  nEByteArray,
  lTString,
  lTPtrConstChar,
  lTByteArray,
  lEString,
  lEPtrConstChar,
  lEByteArray,
  eQString,
  eQPtrConstChar,
  eQByteArray,
  gTString,
  gTPtrConstChar,
  gTByteArray,
  gEString,
  gEPtrConstChar,
  gEByteArray,
  get,
  lT,
  lE,
  gT,
  gE,
  eQ,
  nE,
  QLatin1StringPtr (..),
  chop,
  truncate,
  QLatin1StringConst (..),
  castQLatin1StringToConst,
  QLatin1String (..),
  castQLatin1StringToNonconst,
  new,
  newWithCharPtr,
  newWithCharPtrRange,
  newWithCharPtrAndSize,
  newWithByteArray,
  newCopy,
  QLatin1StringSuper (..),
  QLatin1StringSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QChar as M16
import qualified Graphics.UI.Qtah.Generated.Core.QLatin1Char as M56
import 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

foreign import ccall "genpop__QLatin1String_new" new' ::  HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_newWithCharPtr" newWithCharPtr' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_newWithCharPtrRange" newWithCharPtrRange' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_newWithCharPtrAndSize" newWithCharPtrAndSize' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_newCopy" newCopy' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QLatin1String)
foreign import ccall "genpop__QLatin1String_at" at' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M56.QLatin1Char)
foreign import ccall "genpop__QLatin1String_back" back' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M56.QLatin1Char)
foreign import ccall "genpop__QLatin1String_chop" chop' ::  HoppyF.Ptr QLatin1String -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLatin1String_chopped" chopped' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_dataString" dataString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QLatin1String_front" front' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr M56.QLatin1Char)
foreign import ccall "genpop__QLatin1String_isEmpty" isEmpty' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_isNull" isNull' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_latin1" latin1' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QLatin1String_left" left' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_mid" mid' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_midWithLength" midWithLength' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_right" right' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_size" size' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLatin1String_trimmed" trimmed' ::  HoppyF.Ptr QLatin1StringConst -> HoppyP.IO (HoppyF.Ptr QLatin1StringConst)
foreign import ccall "genpop__QLatin1String_truncate" truncate' ::  HoppyF.Ptr QLatin1String -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLatin1String_endsWithLatin1String" endsWithLatin1String' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_endsWithLatin1StringWithCase" endsWithLatin1StringWithCase' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_endsWithChar" endsWithChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_endsWithCharWithCase" endsWithCharWithCase' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M16.QCharConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_startsWithLatin1String" startsWithLatin1String' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_startsWithLatin1StringWithCase" startsWithLatin1StringWithCase' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_startsWithCharWith" startsWithCharWith' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_startsWithCharWithCase" startsWithCharWithCase' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M16.QCharConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_NEString" nEString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_NEPtrConstChar" nEPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_NEByteArray" nEByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LTString" lTString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LTPtrConstChar" lTPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LTByteArray" lTByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LEString" lEString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LEPtrConstChar" lEPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LEByteArray" lEByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_EQString" eQString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_EQPtrConstChar" eQPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_EQByteArray" eQByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GTString" gTString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GTPtrConstChar" gTPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GTByteArray" gTByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GEString" gEString' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GEPtrConstChar" gEPtrConstChar' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GEByteArray" gEByteArray' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_get" get' ::  HoppyF.Ptr QLatin1StringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M56.QLatin1Char)
foreign import ccall "genpop__QLatin1String_LT" lT' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_LE" lE' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GT" gT' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_GE" gE' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_EQ" eQ' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLatin1String_NE" nE' ::  HoppyF.Ptr QLatin1StringConst -> HoppyF.Ptr QLatin1StringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QLatin1String" delete'QLatin1String :: HoppyF.Ptr QLatin1StringConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLatin1String" deletePtr'QLatin1String :: HoppyF.FunPtr (HoppyF.Ptr QLatin1StringConst -> HoppyP.IO ())

class QLatin1StringValue a where
  withQLatin1StringPtr :: a -> (QLatin1StringConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLatin1StringConstPtr a => QLatin1StringValue a where
  withQLatin1StringPtr = HoppyP.flip ($) . toQLatin1StringConst

class (HoppyFHR.CppPtr this) => QLatin1StringConstPtr this where
  toQLatin1StringConst :: this -> QLatin1StringConst

at :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M56.QLatin1Char)
at arg'1 arg'2 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M56.QLatin1Char
  (at' arg'1' arg'2')

back :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO M56.QLatin1Char)
back arg'1 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M56.QLatin1Char
  (back' arg'1')

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

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

front :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO M56.QLatin1Char)
front arg'1 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M56.QLatin1Char
  (front' arg'1')

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

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

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

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

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

midWithLength :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QLatin1String)
midWithLength arg'1 arg'2 arg'3 =
  withQLatin1StringPtr 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.decodeAndDelete . QLatin1StringConst) =<<
  (midWithLength' arg'1' arg'2' arg'3')

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

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

trimmed :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.IO QLatin1String)
trimmed arg'1 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QLatin1StringConst) =<<
  (trimmed' arg'1')

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

endsWithLatin1StringWithCase :: (QLatin1StringValue this, QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Bool)
endsWithLatin1StringWithCase arg'1 arg'2 arg'3 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWithLatin1StringWithCase' arg'1' arg'2' arg'3')

endsWithChar :: (QLatin1StringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
endsWithChar arg'1 arg'2 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWithChar' arg'1' arg'2')

endsWithCharWithCase :: (QLatin1StringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Bool)
endsWithCharWithCase arg'1 arg'2 arg'3 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (endsWithCharWithCase' arg'1' arg'2' arg'3')

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

startsWithLatin1StringWithCase :: (QLatin1StringValue this, QLatin1StringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Bool)
startsWithLatin1StringWithCase arg'1 arg'2 arg'3 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQLatin1StringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWithLatin1StringWithCase' arg'1' arg'2' arg'3')

startsWithCharWith :: (QLatin1StringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startsWithCharWith arg'1 arg'2 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWithCharWith' arg'1' arg'2')

startsWithCharWithCase :: (QLatin1StringValue this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtCaseSensitivity) -> (HoppyP.IO HoppyP.Bool)
startsWithCharWithCase arg'1 arg'2 arg'3 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startsWithCharWithCase' arg'1' arg'2' arg'3')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

get :: (QLatin1StringValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M56.QLatin1Char)
get arg'1 arg'2 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M56.QLatin1Char
  (get' arg'1' arg'2')

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

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

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

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

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

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

class (QLatin1StringConstPtr this) => QLatin1StringPtr this where
  toQLatin1String :: this -> QLatin1String

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

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

data QLatin1StringConst =
    QLatin1StringConst (HoppyF.Ptr QLatin1StringConst)
  | QLatin1StringConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLatin1StringConst)
  deriving (HoppyP.Show)

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

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

castQLatin1StringToConst :: QLatin1String -> QLatin1StringConst
castQLatin1StringToConst (QLatin1String ptr') = QLatin1StringConst $ HoppyF.castPtr ptr'
castQLatin1StringToConst (QLatin1StringGc fptr' ptr') = QLatin1StringConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QLatin1StringConst QLatin1String where copy = newCopy

instance QLatin1StringConstPtr QLatin1StringConst where
  toQLatin1StringConst = HoppyP.id

data QLatin1String =
    QLatin1String (HoppyF.Ptr QLatin1String)
  | QLatin1StringGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLatin1String)
  deriving (HoppyP.Show)

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

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

castQLatin1StringToNonconst :: QLatin1StringConst -> QLatin1String
castQLatin1StringToNonconst (QLatin1StringConst ptr') = QLatin1String $ HoppyF.castPtr ptr'
castQLatin1StringToNonconst (QLatin1StringConstGc fptr' ptr') = QLatin1StringGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QLatin1String QLatin1String where copy = newCopy

instance QLatin1StringConstPtr QLatin1String where
  toQLatin1StringConst (QLatin1String ptr') = QLatin1StringConst $ (HoppyF.castPtr :: HoppyF.Ptr QLatin1String -> HoppyF.Ptr QLatin1StringConst) ptr'
  toQLatin1StringConst (QLatin1StringGc fptr' ptr') = QLatin1StringConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLatin1String -> HoppyF.Ptr QLatin1StringConst) ptr'

instance QLatin1StringPtr QLatin1String where
  toQLatin1String = HoppyP.id

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

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

newWithCharPtrRange :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QLatin1String)
newWithCharPtrRange arg'1 arg'2 =
  let arg'1' = arg'1 in
  let arg'2' = arg'2 in
  HoppyP.fmap QLatin1String
  (newWithCharPtrRange' arg'1' arg'2')

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

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

newCopy :: (QLatin1StringValue arg'1) => (arg'1) -> (HoppyP.IO QLatin1String)
newCopy arg'1 =
  withQLatin1StringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QLatin1String
  (newCopy' arg'1')

class QLatin1StringSuper a where
  downToQLatin1String :: a -> QLatin1String


class QLatin1StringSuperConst a where
  downToQLatin1StringConst :: a -> QLatin1StringConst


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

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

instance HoppyFHR.Decodable QLatin1String (QLatin1String) where
  decode = HoppyFHR.decode . toQLatin1StringConst

instance HoppyFHR.Decodable QLatin1StringConst (QLatin1String) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc