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

module Graphics.UI.Qtah.Generated.Core.QChar (
  QCharValue (..),
  QCharConstPtr (..),
  category,
  cell,
  combiningClass,
  decomposition,
  decompositionTag,
  digitValue,
  direction,
  hasMirrored,
  isDigit,
  isHighSurrogate,
  isLetter,
  isLetterOrNumber,
  isLowSurrogate,
  isLower,
  isMark,
  isNull,
  isNumber,
  isPrint,
  isPunct,
  isSpace,
  isSymbol,
  isTitleCase,
  isUpper,
  joiningType,
  mirroredChar,
  row,
  script,
  toCaseFolded,
  toLatin1,
  toLower,
  toTitleCase,
  toUpper,
  unicode,
  unicodeVersion,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QCharPtr (..),
  unicodeRef,
  aSSIGN,
  fromLatin1,
  currentUnicodeVersion,
  categoryStatic,
  combiningClassStatic,
  decompositionStatic,
  decompositionTagStatic,
  digitValueStatic,
  directionStatic,
  hasMirroredStatic,
  highSurrogate,
  isDigitStatic,
  isHighSurrogateStatic,
  isLetterStatic,
  isLetterOrNumberStatic,
  isLowSurrogateStatic,
  isLowerStatic,
  isMarkStatic,
  isNonCharacterStatic,
  isNumberStatic,
  isPrintStatic,
  isPunctStatic,
  isSpaceStatic,
  isSurrogateStatic,
  isSymbolStatic,
  isTitleCaseStatic,
  isUpperStatic,
  joiningTypeStatic,
  lowSurrogate,
  mirroredCharStatic,
  requiresSurrogates,
  scriptStatic,
  surrogateToUcs4,
  surrogateToUcs4WithQChar,
  toCaseFoldedStatic,
  toLowerStatic,
  toTitleCaseStatic,
  toUpperStatic,
  unicodeVersionStatic,
  QCharConst (..),
  castQCharToConst,
  QChar (..),
  castQCharToNonconst,
  new,
  newFromCellRow,
  newFromInt,
  newFromSpecialCharacter,
  newCopy,
  QCharSuper (..),
  QCharSuperConst (..),
  QCharCategory (..),
  QCharDecomposition (..),
  QCharDirection (..),
  QCharJoiningType (..),
  QCharScript (..),
  QCharSpecialCharacter (..),
  QCharUnicodeVersion (..),
  ) where

import qualified Data.Char as QtahDC
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 {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QChar_new" new' ::  HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "genpop__QChar_newFromCellRow" newFromCellRow' ::  HoppyFC.CUChar -> HoppyFC.CUChar -> HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "genpop__QChar_newFromInt" newFromInt' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "genpop__QChar_newFromSpecialCharacter" newFromSpecialCharacter' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "genpop__QChar_newCopy" newCopy' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "genpop__QChar_category" category' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_cell" cell' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CUChar
foreign import ccall "genpop__QChar_combiningClass" combiningClass' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CUChar
foreign import ccall "genpop__QChar_decomposition" decomposition' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QChar_decompositionTag" decompositionTag' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_digitValue" digitValue' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_direction" direction' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_hasMirrored" hasMirrored' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isDigit" isDigit' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isHighSurrogate" isHighSurrogate' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLetter" isLetter' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLetterOrNumber" isLetterOrNumber' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLowSurrogate" isLowSurrogate' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLower" isLower' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isMark" isMark' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isNull" isNull' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isNumber" isNumber' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isPrint" isPrint' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isPunct" isPunct' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isSpace" isSpace' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isSymbol" isSymbol' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isTitleCase" isTitleCase' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isUpper" isUpper' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_joiningType" joiningType' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_mirroredChar" mirroredChar' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_row" row' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CUChar
foreign import ccall "genpop__QChar_script" script' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_toCaseFolded" toCaseFolded' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_toLatin1" toLatin1' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CChar
foreign import ccall "genpop__QChar_toLower" toLower' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_toTitleCase" toTitleCase' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_toUpper" toUpper' ::  HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_unicode" unicode' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CUShort
foreign import ccall "genpop__QChar_unicodeRef" unicodeRef' ::  HoppyF.Ptr QChar -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUShort)
foreign import ccall "genpop__QChar_unicodeVersion" unicodeVersion' ::  HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_fromLatin1" fromLatin1' ::  HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QCharConst)
foreign import ccall "genpop__QChar_currentUnicodeVersion" currentUnicodeVersion' ::  HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_categoryStatic" categoryStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_combiningClassStatic" combiningClassStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUChar
foreign import ccall "genpop__QChar_decompositionStatic" decompositionStatic' ::  HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QChar_decompositionTagStatic" decompositionTagStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_digitValueStatic" digitValueStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_directionStatic" directionStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_hasMirroredStatic" hasMirroredStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_highSurrogate" highSurrogate' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isDigitStatic" isDigitStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isHighSurrogateStatic" isHighSurrogateStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLetterStatic" isLetterStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLetterOrNumberStatic" isLetterOrNumberStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLowSurrogateStatic" isLowSurrogateStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isLowerStatic" isLowerStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isMarkStatic" isMarkStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isNonCharacterStatic" isNonCharacterStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isNumberStatic" isNumberStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isPrintStatic" isPrintStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isPunctStatic" isPunctStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isSpaceStatic" isSpaceStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isSurrogateStatic" isSurrogateStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isSymbolStatic" isSymbolStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isTitleCaseStatic" isTitleCaseStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_isUpperStatic" isUpperStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_joiningTypeStatic" joiningTypeStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_lowSurrogate" lowSurrogate' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUShort
foreign import ccall "genpop__QChar_mirroredCharStatic" mirroredCharStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_requiresSurrogates" requiresSurrogates' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_scriptStatic" scriptStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_surrogateToUcs4" surrogateToUcs4' ::  HoppyFC.CUShort -> HoppyFC.CUShort -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_surrogateToUcs4WithQChar" surrogateToUcs4WithQChar' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_toCaseFoldedStatic" toCaseFoldedStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_toLowerStatic" toLowerStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_toTitleCaseStatic" toTitleCaseStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_toUpperStatic" toUpperStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QChar_unicodeVersionStatic" unicodeVersionStatic' ::  HoppyFC.CUInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QChar_EQ" eQ' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_NE" nE' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_LT" lT' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_LE" lE' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_GT" gT' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_GE" gE' ::  HoppyF.Ptr QCharConst -> HoppyF.Ptr QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QChar_ASSIGN" aSSIGN' ::  HoppyF.Ptr QChar -> HoppyF.Ptr QCharConst -> HoppyP.IO (HoppyF.Ptr QChar)
foreign import ccall "gendel__QChar" delete'QChar :: HoppyF.Ptr QCharConst -> HoppyP.IO ()
foreign import ccall "&gendel__QChar" deletePtr'QChar :: HoppyF.FunPtr (HoppyF.Ptr QCharConst -> HoppyP.IO ())

class QCharValue a where
  withQCharPtr :: a -> (QCharConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QCharConstPtr a => QCharValue a where
  withQCharPtr = HoppyP.flip ($) . toQCharConst

instance {-# OVERLAPPING #-} QCharValue (QtahP.Char) where
  withQCharPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QCharConstPtr this where
  toQCharConst :: this -> QCharConst

category :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharCategory)
category arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (category' arg'1')

cell :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUChar)
cell arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (cell' arg'1')

combiningClass :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUChar)
combiningClass arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (combiningClass' arg'1')

decomposition :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
decomposition arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (decomposition' arg'1')

decompositionTag :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharDecomposition)
decompositionTag arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (decompositionTag' arg'1')

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

direction :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharDirection)
direction arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (direction' arg'1')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

joiningType :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharJoiningType)
joiningType arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (joiningType' arg'1')

mirroredChar :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
mirroredChar arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (mirroredChar' arg'1')

row :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUChar)
row arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (row' arg'1')

script :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharScript)
script arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (script' arg'1')

toCaseFolded :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
toCaseFolded arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (toCaseFolded' arg'1')

toLatin1 :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CChar)
toLatin1 arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toLatin1' arg'1')

toLower :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
toLower arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (toLower' arg'1')

toTitleCase :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
toTitleCase arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (toTitleCase' arg'1')

toUpper :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
toUpper arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (toUpper' arg'1')

unicode :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUShort)
unicode arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (unicode' arg'1')

unicodeVersion :: (QCharValue this) => (this) {- ^ this -} -> (HoppyP.IO QCharUnicodeVersion)
unicodeVersion arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (unicodeVersion' arg'1')

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

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

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

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

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

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

class (QCharConstPtr this) => QCharPtr this where
  toQChar :: this -> QChar

unicodeRef :: (QCharPtr this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUShort))
unicodeRef arg'1 =
  HoppyFHR.withCppPtr (toQChar arg'1) $ \arg'1' ->
  (unicodeRef' arg'1')

aSSIGN :: (QCharPtr this, QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QChar)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQChar arg'1) $ \arg'1' ->
  withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QChar
  (aSSIGN' arg'1' arg'2')

fromLatin1 :: (HoppyFC.CChar) -> (HoppyP.IO QtahP.Char)
fromLatin1 arg'1 =
  let arg'1' = arg'1 in
  (HoppyFHR.decodeAndDelete . QCharConst) =<<
  (fromLatin1' arg'1')

currentUnicodeVersion :: (HoppyP.IO QCharUnicodeVersion)
currentUnicodeVersion =
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (currentUnicodeVersion')

categoryStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharCategory)
categoryStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (categoryStatic' arg'1')

combiningClassStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUChar)
combiningClassStatic arg'1 =
  let arg'1' = arg'1 in
  (combiningClassStatic' arg'1')

decompositionStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QtahP.String)
decompositionStatic arg'1 =
  let arg'1' = arg'1 in
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (decompositionStatic' arg'1')

decompositionTagStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharDecomposition)
decompositionTagStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (decompositionTagStatic' arg'1')

digitValueStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Int)
digitValueStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (digitValueStatic' arg'1')

directionStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharDirection)
directionStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (directionStatic' arg'1')

hasMirroredStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
hasMirroredStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (hasMirroredStatic' arg'1')

highSurrogate :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
highSurrogate arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (highSurrogate' arg'1')

isDigitStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isDigitStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isDigitStatic' arg'1')

isHighSurrogateStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isHighSurrogateStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isHighSurrogateStatic' arg'1')

isLetterStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isLetterStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isLetterStatic' arg'1')

isLetterOrNumberStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isLetterOrNumberStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isLetterOrNumberStatic' arg'1')

isLowSurrogateStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isLowSurrogateStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isLowSurrogateStatic' arg'1')

isLowerStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isLowerStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isLowerStatic' arg'1')

isMarkStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isMarkStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isMarkStatic' arg'1')

isNonCharacterStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isNonCharacterStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isNonCharacterStatic' arg'1')

isNumberStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isNumberStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isNumberStatic' arg'1')

isPrintStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isPrintStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isPrintStatic' arg'1')

isPunctStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isPunctStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isPunctStatic' arg'1')

isSpaceStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isSpaceStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isSpaceStatic' arg'1')

isSurrogateStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isSurrogateStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isSurrogateStatic' arg'1')

isSymbolStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isSymbolStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isSymbolStatic' arg'1')

isTitleCaseStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isTitleCaseStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isTitleCaseStatic' arg'1')

isUpperStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
isUpperStatic arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isUpperStatic' arg'1')

joiningTypeStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharJoiningType)
joiningTypeStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (joiningTypeStatic' arg'1')

lowSurrogate :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUShort)
lowSurrogate arg'1 =
  let arg'1' = arg'1 in
  (lowSurrogate' arg'1')

mirroredCharStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUInt)
mirroredCharStatic arg'1 =
  let arg'1' = arg'1 in
  (mirroredCharStatic' arg'1')

requiresSurrogates :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyP.Bool)
requiresSurrogates arg'1 =
  let arg'1' = arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (requiresSurrogates' arg'1')

scriptStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharScript)
scriptStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (scriptStatic' arg'1')

surrogateToUcs4 :: (HoppyFC.CUShort) -> (HoppyFC.CUShort) -> (HoppyP.IO HoppyFC.CUInt)
surrogateToUcs4 arg'1 arg'2 =
  let arg'1' = arg'1 in
  let arg'2' = arg'2 in
  (surrogateToUcs4' arg'1' arg'2')

surrogateToUcs4WithQChar :: (QCharValue arg'1, QCharValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyFC.CUInt)
surrogateToUcs4WithQChar arg'1 arg'2 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (surrogateToUcs4WithQChar' arg'1' arg'2')

toCaseFoldedStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUInt)
toCaseFoldedStatic arg'1 =
  let arg'1' = arg'1 in
  (toCaseFoldedStatic' arg'1')

toLowerStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUInt)
toLowerStatic arg'1 =
  let arg'1' = arg'1 in
  (toLowerStatic' arg'1')

toTitleCaseStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUInt)
toTitleCaseStatic arg'1 =
  let arg'1' = arg'1 in
  (toTitleCaseStatic' arg'1')

toUpperStatic :: (HoppyFC.CUInt) -> (HoppyP.IO HoppyFC.CUInt)
toUpperStatic arg'1 =
  let arg'1' = arg'1 in
  (toUpperStatic' arg'1')

unicodeVersionStatic :: (HoppyFC.CUInt) -> (HoppyP.IO QCharUnicodeVersion)
unicodeVersionStatic arg'1 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (unicodeVersionStatic' arg'1')

data QCharConst =
    QCharConst (HoppyF.Ptr QCharConst)
  | QCharConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QCharConst)
  deriving (HoppyP.Show)

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

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

castQCharToConst :: QChar -> QCharConst
castQCharToConst (QChar ptr') = QCharConst $ HoppyF.castPtr ptr'
castQCharToConst (QCharGc fptr' ptr') = QCharConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QCharConst QChar where copy = newCopy

instance QCharConstPtr QCharConst where
  toQCharConst = HoppyP.id

data QChar =
    QChar (HoppyF.Ptr QChar)
  | QCharGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QChar)
  deriving (HoppyP.Show)

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

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

castQCharToNonconst :: QCharConst -> QChar
castQCharToNonconst (QCharConst ptr') = QChar $ HoppyF.castPtr ptr'
castQCharToNonconst (QCharConstGc fptr' ptr') = QCharGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QChar QChar where copy = newCopy

instance QCharConstPtr QChar where
  toQCharConst (QChar ptr') = QCharConst $ (HoppyF.castPtr :: HoppyF.Ptr QChar -> HoppyF.Ptr QCharConst) ptr'
  toQCharConst (QCharGc fptr' ptr') = QCharConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QChar -> HoppyF.Ptr QCharConst) ptr'

instance QCharPtr QChar where
  toQChar = HoppyP.id

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

newFromCellRow :: (HoppyFC.CUChar) -> (HoppyFC.CUChar) -> (HoppyP.IO QChar)
newFromCellRow arg'1 arg'2 =
  let arg'1' = arg'1 in
  let arg'2' = arg'2 in
  HoppyP.fmap QChar
  (newFromCellRow' arg'1' arg'2')

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

newFromSpecialCharacter :: (QCharSpecialCharacter) -> (HoppyP.IO QChar)
newFromSpecialCharacter arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QChar
  (newFromSpecialCharacter' arg'1')

newCopy :: (QCharValue arg'1) => (arg'1) -> (HoppyP.IO QChar)
newCopy arg'1 =
  withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QChar
  (newCopy' arg'1')

class QCharSuper a where
  downToQChar :: a -> QChar


class QCharSuperConst a where
  downToQCharConst :: a -> QCharConst


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

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

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

instance HoppyFHR.Encodable QChar (QtahP.Char) where
  encode =
    newFromInt . QtahFHR.coerceIntegral . QtahDC.ord

instance HoppyFHR.Encodable QCharConst (QtahP.Char) where
  encode = HoppyP.fmap (toQCharConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QChar)

instance HoppyFHR.Decodable QChar (QtahP.Char) where
  decode = HoppyFHR.decode . toQCharConst

instance HoppyFHR.Decodable QCharConst (QtahP.Char) where
  decode =
    QtahP.fmap (QtahDC.chr . QtahFHR.coerceIntegral) . unicode

data QCharCategory =
  MarkNonSpacing
  | MarkSpacingCombining
  | MarkEnclosing
  | NumberDecimalDigit
  | NumberLetter
  | NumberOther
  | SeparatorSpace
  | SeparatorLine
  | SeparatorParagraph
  | OtherControl
  | OtherFormat
  | OtherSurrogate
  | OtherPrivateUse
  | OtherNotAssigned
  | LetterUppercase
  | LetterLowercase
  | LetterTitlecase
  | LetterModifier
  | LetterOther
  | PunctuationConnector
  | PunctuationDash
  | PunctuationOpen
  | PunctuationClose
  | PunctuationInitialQuote
  | PunctuationFinalQuote
  | PunctuationOther
  | SymbolMath
  | SymbolCurrency
  | SymbolModifier
  | SymbolOther
  | UnknownQCharCategory (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharCategory where
  fromCppEnum MarkNonSpacing = 0
  fromCppEnum MarkSpacingCombining = 1
  fromCppEnum MarkEnclosing = 2
  fromCppEnum NumberDecimalDigit = 3
  fromCppEnum NumberLetter = 4
  fromCppEnum NumberOther = 5
  fromCppEnum SeparatorSpace = 6
  fromCppEnum SeparatorLine = 7
  fromCppEnum SeparatorParagraph = 8
  fromCppEnum OtherControl = 9
  fromCppEnum OtherFormat = 10
  fromCppEnum OtherSurrogate = 11
  fromCppEnum OtherPrivateUse = 12
  fromCppEnum OtherNotAssigned = 13
  fromCppEnum LetterUppercase = 14
  fromCppEnum LetterLowercase = 15
  fromCppEnum LetterTitlecase = 16
  fromCppEnum LetterModifier = 17
  fromCppEnum LetterOther = 18
  fromCppEnum PunctuationConnector = 19
  fromCppEnum PunctuationDash = 20
  fromCppEnum PunctuationOpen = 21
  fromCppEnum PunctuationClose = 22
  fromCppEnum PunctuationInitialQuote = 23
  fromCppEnum PunctuationFinalQuote = 24
  fromCppEnum PunctuationOther = 25
  fromCppEnum SymbolMath = 26
  fromCppEnum SymbolCurrency = 27
  fromCppEnum SymbolModifier = 28
  fromCppEnum SymbolOther = 29
  fromCppEnum (UnknownQCharCategory n) = n
  
  toCppEnum (0) = MarkNonSpacing
  toCppEnum (1) = MarkSpacingCombining
  toCppEnum (2) = MarkEnclosing
  toCppEnum (3) = NumberDecimalDigit
  toCppEnum (4) = NumberLetter
  toCppEnum (5) = NumberOther
  toCppEnum (6) = SeparatorSpace
  toCppEnum (7) = SeparatorLine
  toCppEnum (8) = SeparatorParagraph
  toCppEnum (9) = OtherControl
  toCppEnum (10) = OtherFormat
  toCppEnum (11) = OtherSurrogate
  toCppEnum (12) = OtherPrivateUse
  toCppEnum (13) = OtherNotAssigned
  toCppEnum (14) = LetterUppercase
  toCppEnum (15) = LetterLowercase
  toCppEnum (16) = LetterTitlecase
  toCppEnum (17) = LetterModifier
  toCppEnum (18) = LetterOther
  toCppEnum (19) = PunctuationConnector
  toCppEnum (20) = PunctuationDash
  toCppEnum (21) = PunctuationOpen
  toCppEnum (22) = PunctuationClose
  toCppEnum (23) = PunctuationInitialQuote
  toCppEnum (24) = PunctuationFinalQuote
  toCppEnum (25) = PunctuationOther
  toCppEnum (26) = SymbolMath
  toCppEnum (27) = SymbolCurrency
  toCppEnum (28) = SymbolModifier
  toCppEnum (29) = SymbolOther
  toCppEnum n = UnknownQCharCategory n

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

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

data QCharDecomposition =
  NoDecomposition
  | Canonical
  | Circle
  | Compat
  | Final
  | Font
  | Fraction
  | Initial
  | Isolated
  | Medial
  | Narrow
  | NoBreak
  | Small
  | Square
  | Sub
  | Super
  | Vertical
  | Wide
  | UnknownQCharDecomposition (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharDecomposition where
  fromCppEnum NoDecomposition = 0
  fromCppEnum Canonical = 1
  fromCppEnum Circle = 8
  fromCppEnum Compat = 16
  fromCppEnum Final = 6
  fromCppEnum Font = 2
  fromCppEnum Fraction = 17
  fromCppEnum Initial = 4
  fromCppEnum Isolated = 7
  fromCppEnum Medial = 5
  fromCppEnum Narrow = 13
  fromCppEnum NoBreak = 3
  fromCppEnum Small = 14
  fromCppEnum Square = 15
  fromCppEnum Sub = 10
  fromCppEnum Super = 9
  fromCppEnum Vertical = 11
  fromCppEnum Wide = 12
  fromCppEnum (UnknownQCharDecomposition n) = n
  
  toCppEnum (0) = NoDecomposition
  toCppEnum (1) = Canonical
  toCppEnum (2) = Font
  toCppEnum (3) = NoBreak
  toCppEnum (4) = Initial
  toCppEnum (5) = Medial
  toCppEnum (6) = Final
  toCppEnum (7) = Isolated
  toCppEnum (8) = Circle
  toCppEnum (9) = Super
  toCppEnum (10) = Sub
  toCppEnum (11) = Vertical
  toCppEnum (12) = Wide
  toCppEnum (13) = Narrow
  toCppEnum (14) = Small
  toCppEnum (15) = Square
  toCppEnum (16) = Compat
  toCppEnum (17) = Fraction
  toCppEnum n = UnknownQCharDecomposition n

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

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

data QCharDirection =
  DirAl
  | DirAn
  | DirB
  | DirBn
  | DirCs
  | DirEn
  | DirEs
  | DirEt
  | DirL
  | DirLre
  | DirLro
  | DirNsm
  | DirOn
  | DirPdf
  | DirR
  | DirRle
  | DirRlo
  | DirS
  | DirWs
  | UnknownQCharDirection (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharDirection where
  fromCppEnum DirAl = 13
  fromCppEnum DirAn = 5
  fromCppEnum DirB = 7
  fromCppEnum DirBn = 18
  fromCppEnum DirCs = 6
  fromCppEnum DirEn = 2
  fromCppEnum DirEs = 3
  fromCppEnum DirEt = 4
  fromCppEnum DirL = 0
  fromCppEnum DirLre = 11
  fromCppEnum DirLro = 12
  fromCppEnum DirNsm = 17
  fromCppEnum DirOn = 10
  fromCppEnum DirPdf = 16
  fromCppEnum DirR = 1
  fromCppEnum DirRle = 14
  fromCppEnum DirRlo = 15
  fromCppEnum DirS = 8
  fromCppEnum DirWs = 9
  fromCppEnum (UnknownQCharDirection n) = n
  
  toCppEnum (0) = DirL
  toCppEnum (1) = DirR
  toCppEnum (2) = DirEn
  toCppEnum (3) = DirEs
  toCppEnum (4) = DirEt
  toCppEnum (5) = DirAn
  toCppEnum (6) = DirCs
  toCppEnum (7) = DirB
  toCppEnum (8) = DirS
  toCppEnum (9) = DirWs
  toCppEnum (10) = DirOn
  toCppEnum (11) = DirLre
  toCppEnum (12) = DirLro
  toCppEnum (13) = DirAl
  toCppEnum (14) = DirRle
  toCppEnum (15) = DirRlo
  toCppEnum (16) = DirPdf
  toCppEnum (17) = DirNsm
  toCppEnum (18) = DirBn
  toCppEnum n = UnknownQCharDirection n

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

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

data QCharJoiningType =
  JoiningNone
  | JoiningCausing
  | JoiningDual
  | JoiningRight
  | JoiningLeft
  | JoiningTransparent
  | UnknownQCharJoiningType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharJoiningType where
  fromCppEnum JoiningNone = 0
  fromCppEnum JoiningCausing = 1
  fromCppEnum JoiningDual = 2
  fromCppEnum JoiningRight = 3
  fromCppEnum JoiningLeft = 4
  fromCppEnum JoiningTransparent = 5
  fromCppEnum (UnknownQCharJoiningType n) = n
  
  toCppEnum (0) = JoiningNone
  toCppEnum (1) = JoiningCausing
  toCppEnum (2) = JoiningDual
  toCppEnum (3) = JoiningRight
  toCppEnum (4) = JoiningLeft
  toCppEnum (5) = JoiningTransparent
  toCppEnum n = UnknownQCharJoiningType n

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

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

data QCharScript =
  ScriptUnknown
  | ScriptInherited
  | ScriptCommon
  | ScriptLatin
  | ScriptGreek
  | ScriptCyrillic
  | ScriptArmenian
  | ScriptHebrew
  | ScriptArabic
  | ScriptSyriac
  | ScriptThaana
  | ScriptDevanagari
  | ScriptBengali
  | ScriptGurmukhi
  | ScriptGujarati
  | ScriptOriya
  | ScriptTamil
  | ScriptTelugu
  | ScriptKannada
  | ScriptMalayalam
  | ScriptSinhala
  | ScriptThai
  | ScriptLao
  | ScriptTibetan
  | ScriptMyanmar
  | ScriptGeorgian
  | ScriptHangul
  | ScriptEthiopic
  | ScriptCherokee
  | ScriptCanadianAboriginal
  | ScriptOgham
  | ScriptRunic
  | ScriptKhmer
  | ScriptMongolian
  | ScriptHiragana
  | ScriptKatakana
  | ScriptBopomofo
  | ScriptHan
  | ScriptYi
  | ScriptOldItalic
  | ScriptGothic
  | ScriptDeseret
  | ScriptTagalog
  | ScriptHanunoo
  | ScriptBuhid
  | ScriptTagbanwa
  | ScriptCoptic
  | ScriptLimbu
  | ScriptTaiLe
  | ScriptLinearB
  | ScriptUgaritic
  | ScriptShavian
  | ScriptOsmanya
  | ScriptCypriot
  | ScriptBraille
  | ScriptBuginese
  | ScriptNewTaiLue
  | ScriptGlagolitic
  | ScriptTifinagh
  | ScriptSylotiNagri
  | ScriptOldPersian
  | ScriptKharoshthi
  | ScriptBalinese
  | ScriptCuneiform
  | ScriptPhoenician
  | ScriptPhagsPa
  | ScriptNko
  | ScriptSundanese
  | ScriptLepcha
  | ScriptOlChiki
  | ScriptVai
  | ScriptSaurashtra
  | ScriptKayahLi
  | ScriptRejang
  | ScriptLycian
  | ScriptCarian
  | ScriptLydian
  | ScriptCham
  | ScriptTaiTham
  | ScriptTaiViet
  | ScriptAvestan
  | ScriptEgyptianHieroglyphs
  | ScriptSamaritan
  | ScriptLisu
  | ScriptBamum
  | ScriptJavanese
  | ScriptMeeteiMayek
  | ScriptImperialAramaic
  | ScriptOldSouthArabian
  | ScriptInscriptionalParthian
  | ScriptInscriptionalPahlavi
  | ScriptOldTurkic
  | ScriptKaithi
  | ScriptBatak
  | ScriptBrahmi
  | ScriptMandaic
  | ScriptChakma
  | ScriptMeroiticCursive
  | ScriptMeroiticHieroglyphs
  | ScriptMiao
  | ScriptSharada
  | ScriptSoraSompeng
  | ScriptTakri
  | ScriptCaucasianAlbanian
  | ScriptBassaVah
  | ScriptDuployan
  | ScriptElbasan
  | ScriptGrantha
  | ScriptPahawhHmong
  | ScriptKhojki
  | ScriptLinearA
  | ScriptMahajani
  | ScriptManichaean
  | ScriptMendeKikakui
  | ScriptModi
  | ScriptMro
  | ScriptOldNorthArabian
  | ScriptNabataean
  | ScriptPalmyrene
  | ScriptPauCinHau
  | ScriptOldPermic
  | ScriptPsalterPahlavi
  | ScriptSiddham
  | ScriptKhudawadi
  | ScriptTirhuta
  | ScriptWarangCiti
  | ScriptAhom
  | ScriptAnatolianHieroglyphs
  | ScriptHatran
  | ScriptMultani
  | ScriptOldHungarian
  | ScriptSignWriting
  | ScriptAdlam
  | ScriptBhaiksuki
  | ScriptMarchen
  | ScriptNewa
  | ScriptOsage
  | ScriptTangut
  | ScriptMasaramGondi
  | ScriptNushu
  | ScriptSoyombo
  | ScriptZanabazarSquare
  | UnknownQCharScript (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharScript where
  fromCppEnum ScriptUnknown = 0
  fromCppEnum ScriptInherited = 1
  fromCppEnum ScriptCommon = 2
  fromCppEnum ScriptLatin = 3
  fromCppEnum ScriptGreek = 4
  fromCppEnum ScriptCyrillic = 5
  fromCppEnum ScriptArmenian = 6
  fromCppEnum ScriptHebrew = 7
  fromCppEnum ScriptArabic = 8
  fromCppEnum ScriptSyriac = 9
  fromCppEnum ScriptThaana = 10
  fromCppEnum ScriptDevanagari = 11
  fromCppEnum ScriptBengali = 12
  fromCppEnum ScriptGurmukhi = 13
  fromCppEnum ScriptGujarati = 14
  fromCppEnum ScriptOriya = 15
  fromCppEnum ScriptTamil = 16
  fromCppEnum ScriptTelugu = 17
  fromCppEnum ScriptKannada = 18
  fromCppEnum ScriptMalayalam = 19
  fromCppEnum ScriptSinhala = 20
  fromCppEnum ScriptThai = 21
  fromCppEnum ScriptLao = 22
  fromCppEnum ScriptTibetan = 23
  fromCppEnum ScriptMyanmar = 24
  fromCppEnum ScriptGeorgian = 25
  fromCppEnum ScriptHangul = 26
  fromCppEnum ScriptEthiopic = 27
  fromCppEnum ScriptCherokee = 28
  fromCppEnum ScriptCanadianAboriginal = 29
  fromCppEnum ScriptOgham = 30
  fromCppEnum ScriptRunic = 31
  fromCppEnum ScriptKhmer = 32
  fromCppEnum ScriptMongolian = 33
  fromCppEnum ScriptHiragana = 34
  fromCppEnum ScriptKatakana = 35
  fromCppEnum ScriptBopomofo = 36
  fromCppEnum ScriptHan = 37
  fromCppEnum ScriptYi = 38
  fromCppEnum ScriptOldItalic = 39
  fromCppEnum ScriptGothic = 40
  fromCppEnum ScriptDeseret = 41
  fromCppEnum ScriptTagalog = 42
  fromCppEnum ScriptHanunoo = 43
  fromCppEnum ScriptBuhid = 44
  fromCppEnum ScriptTagbanwa = 45
  fromCppEnum ScriptCoptic = 46
  fromCppEnum ScriptLimbu = 47
  fromCppEnum ScriptTaiLe = 48
  fromCppEnum ScriptLinearB = 49
  fromCppEnum ScriptUgaritic = 50
  fromCppEnum ScriptShavian = 51
  fromCppEnum ScriptOsmanya = 52
  fromCppEnum ScriptCypriot = 53
  fromCppEnum ScriptBraille = 54
  fromCppEnum ScriptBuginese = 55
  fromCppEnum ScriptNewTaiLue = 56
  fromCppEnum ScriptGlagolitic = 57
  fromCppEnum ScriptTifinagh = 58
  fromCppEnum ScriptSylotiNagri = 59
  fromCppEnum ScriptOldPersian = 60
  fromCppEnum ScriptKharoshthi = 61
  fromCppEnum ScriptBalinese = 62
  fromCppEnum ScriptCuneiform = 63
  fromCppEnum ScriptPhoenician = 64
  fromCppEnum ScriptPhagsPa = 65
  fromCppEnum ScriptNko = 66
  fromCppEnum ScriptSundanese = 67
  fromCppEnum ScriptLepcha = 68
  fromCppEnum ScriptOlChiki = 69
  fromCppEnum ScriptVai = 70
  fromCppEnum ScriptSaurashtra = 71
  fromCppEnum ScriptKayahLi = 72
  fromCppEnum ScriptRejang = 73
  fromCppEnum ScriptLycian = 74
  fromCppEnum ScriptCarian = 75
  fromCppEnum ScriptLydian = 76
  fromCppEnum ScriptCham = 77
  fromCppEnum ScriptTaiTham = 78
  fromCppEnum ScriptTaiViet = 79
  fromCppEnum ScriptAvestan = 80
  fromCppEnum ScriptEgyptianHieroglyphs = 81
  fromCppEnum ScriptSamaritan = 82
  fromCppEnum ScriptLisu = 83
  fromCppEnum ScriptBamum = 84
  fromCppEnum ScriptJavanese = 85
  fromCppEnum ScriptMeeteiMayek = 86
  fromCppEnum ScriptImperialAramaic = 87
  fromCppEnum ScriptOldSouthArabian = 88
  fromCppEnum ScriptInscriptionalParthian = 89
  fromCppEnum ScriptInscriptionalPahlavi = 90
  fromCppEnum ScriptOldTurkic = 91
  fromCppEnum ScriptKaithi = 92
  fromCppEnum ScriptBatak = 93
  fromCppEnum ScriptBrahmi = 94
  fromCppEnum ScriptMandaic = 95
  fromCppEnum ScriptChakma = 96
  fromCppEnum ScriptMeroiticCursive = 97
  fromCppEnum ScriptMeroiticHieroglyphs = 98
  fromCppEnum ScriptMiao = 99
  fromCppEnum ScriptSharada = 100
  fromCppEnum ScriptSoraSompeng = 101
  fromCppEnum ScriptTakri = 102
  fromCppEnum ScriptCaucasianAlbanian = 103
  fromCppEnum ScriptBassaVah = 104
  fromCppEnum ScriptDuployan = 105
  fromCppEnum ScriptElbasan = 106
  fromCppEnum ScriptGrantha = 107
  fromCppEnum ScriptPahawhHmong = 108
  fromCppEnum ScriptKhojki = 109
  fromCppEnum ScriptLinearA = 110
  fromCppEnum ScriptMahajani = 111
  fromCppEnum ScriptManichaean = 112
  fromCppEnum ScriptMendeKikakui = 113
  fromCppEnum ScriptModi = 114
  fromCppEnum ScriptMro = 115
  fromCppEnum ScriptOldNorthArabian = 116
  fromCppEnum ScriptNabataean = 117
  fromCppEnum ScriptPalmyrene = 118
  fromCppEnum ScriptPauCinHau = 119
  fromCppEnum ScriptOldPermic = 120
  fromCppEnum ScriptPsalterPahlavi = 121
  fromCppEnum ScriptSiddham = 122
  fromCppEnum ScriptKhudawadi = 123
  fromCppEnum ScriptTirhuta = 124
  fromCppEnum ScriptWarangCiti = 125
  fromCppEnum ScriptAhom = 126
  fromCppEnum ScriptAnatolianHieroglyphs = 127
  fromCppEnum ScriptHatran = 128
  fromCppEnum ScriptMultani = 129
  fromCppEnum ScriptOldHungarian = 130
  fromCppEnum ScriptSignWriting = 131
  fromCppEnum ScriptAdlam = 132
  fromCppEnum ScriptBhaiksuki = 133
  fromCppEnum ScriptMarchen = 134
  fromCppEnum ScriptNewa = 135
  fromCppEnum ScriptOsage = 136
  fromCppEnum ScriptTangut = 137
  fromCppEnum ScriptMasaramGondi = 138
  fromCppEnum ScriptNushu = 139
  fromCppEnum ScriptSoyombo = 140
  fromCppEnum ScriptZanabazarSquare = 141
  fromCppEnum (UnknownQCharScript n) = n
  
  toCppEnum (0) = ScriptUnknown
  toCppEnum (1) = ScriptInherited
  toCppEnum (2) = ScriptCommon
  toCppEnum (3) = ScriptLatin
  toCppEnum (4) = ScriptGreek
  toCppEnum (5) = ScriptCyrillic
  toCppEnum (6) = ScriptArmenian
  toCppEnum (7) = ScriptHebrew
  toCppEnum (8) = ScriptArabic
  toCppEnum (9) = ScriptSyriac
  toCppEnum (10) = ScriptThaana
  toCppEnum (11) = ScriptDevanagari
  toCppEnum (12) = ScriptBengali
  toCppEnum (13) = ScriptGurmukhi
  toCppEnum (14) = ScriptGujarati
  toCppEnum (15) = ScriptOriya
  toCppEnum (16) = ScriptTamil
  toCppEnum (17) = ScriptTelugu
  toCppEnum (18) = ScriptKannada
  toCppEnum (19) = ScriptMalayalam
  toCppEnum (20) = ScriptSinhala
  toCppEnum (21) = ScriptThai
  toCppEnum (22) = ScriptLao
  toCppEnum (23) = ScriptTibetan
  toCppEnum (24) = ScriptMyanmar
  toCppEnum (25) = ScriptGeorgian
  toCppEnum (26) = ScriptHangul
  toCppEnum (27) = ScriptEthiopic
  toCppEnum (28) = ScriptCherokee
  toCppEnum (29) = ScriptCanadianAboriginal
  toCppEnum (30) = ScriptOgham
  toCppEnum (31) = ScriptRunic
  toCppEnum (32) = ScriptKhmer
  toCppEnum (33) = ScriptMongolian
  toCppEnum (34) = ScriptHiragana
  toCppEnum (35) = ScriptKatakana
  toCppEnum (36) = ScriptBopomofo
  toCppEnum (37) = ScriptHan
  toCppEnum (38) = ScriptYi
  toCppEnum (39) = ScriptOldItalic
  toCppEnum (40) = ScriptGothic
  toCppEnum (41) = ScriptDeseret
  toCppEnum (42) = ScriptTagalog
  toCppEnum (43) = ScriptHanunoo
  toCppEnum (44) = ScriptBuhid
  toCppEnum (45) = ScriptTagbanwa
  toCppEnum (46) = ScriptCoptic
  toCppEnum (47) = ScriptLimbu
  toCppEnum (48) = ScriptTaiLe
  toCppEnum (49) = ScriptLinearB
  toCppEnum (50) = ScriptUgaritic
  toCppEnum (51) = ScriptShavian
  toCppEnum (52) = ScriptOsmanya
  toCppEnum (53) = ScriptCypriot
  toCppEnum (54) = ScriptBraille
  toCppEnum (55) = ScriptBuginese
  toCppEnum (56) = ScriptNewTaiLue
  toCppEnum (57) = ScriptGlagolitic
  toCppEnum (58) = ScriptTifinagh
  toCppEnum (59) = ScriptSylotiNagri
  toCppEnum (60) = ScriptOldPersian
  toCppEnum (61) = ScriptKharoshthi
  toCppEnum (62) = ScriptBalinese
  toCppEnum (63) = ScriptCuneiform
  toCppEnum (64) = ScriptPhoenician
  toCppEnum (65) = ScriptPhagsPa
  toCppEnum (66) = ScriptNko
  toCppEnum (67) = ScriptSundanese
  toCppEnum (68) = ScriptLepcha
  toCppEnum (69) = ScriptOlChiki
  toCppEnum (70) = ScriptVai
  toCppEnum (71) = ScriptSaurashtra
  toCppEnum (72) = ScriptKayahLi
  toCppEnum (73) = ScriptRejang
  toCppEnum (74) = ScriptLycian
  toCppEnum (75) = ScriptCarian
  toCppEnum (76) = ScriptLydian
  toCppEnum (77) = ScriptCham
  toCppEnum (78) = ScriptTaiTham
  toCppEnum (79) = ScriptTaiViet
  toCppEnum (80) = ScriptAvestan
  toCppEnum (81) = ScriptEgyptianHieroglyphs
  toCppEnum (82) = ScriptSamaritan
  toCppEnum (83) = ScriptLisu
  toCppEnum (84) = ScriptBamum
  toCppEnum (85) = ScriptJavanese
  toCppEnum (86) = ScriptMeeteiMayek
  toCppEnum (87) = ScriptImperialAramaic
  toCppEnum (88) = ScriptOldSouthArabian
  toCppEnum (89) = ScriptInscriptionalParthian
  toCppEnum (90) = ScriptInscriptionalPahlavi
  toCppEnum (91) = ScriptOldTurkic
  toCppEnum (92) = ScriptKaithi
  toCppEnum (93) = ScriptBatak
  toCppEnum (94) = ScriptBrahmi
  toCppEnum (95) = ScriptMandaic
  toCppEnum (96) = ScriptChakma
  toCppEnum (97) = ScriptMeroiticCursive
  toCppEnum (98) = ScriptMeroiticHieroglyphs
  toCppEnum (99) = ScriptMiao
  toCppEnum (100) = ScriptSharada
  toCppEnum (101) = ScriptSoraSompeng
  toCppEnum (102) = ScriptTakri
  toCppEnum (103) = ScriptCaucasianAlbanian
  toCppEnum (104) = ScriptBassaVah
  toCppEnum (105) = ScriptDuployan
  toCppEnum (106) = ScriptElbasan
  toCppEnum (107) = ScriptGrantha
  toCppEnum (108) = ScriptPahawhHmong
  toCppEnum (109) = ScriptKhojki
  toCppEnum (110) = ScriptLinearA
  toCppEnum (111) = ScriptMahajani
  toCppEnum (112) = ScriptManichaean
  toCppEnum (113) = ScriptMendeKikakui
  toCppEnum (114) = ScriptModi
  toCppEnum (115) = ScriptMro
  toCppEnum (116) = ScriptOldNorthArabian
  toCppEnum (117) = ScriptNabataean
  toCppEnum (118) = ScriptPalmyrene
  toCppEnum (119) = ScriptPauCinHau
  toCppEnum (120) = ScriptOldPermic
  toCppEnum (121) = ScriptPsalterPahlavi
  toCppEnum (122) = ScriptSiddham
  toCppEnum (123) = ScriptKhudawadi
  toCppEnum (124) = ScriptTirhuta
  toCppEnum (125) = ScriptWarangCiti
  toCppEnum (126) = ScriptAhom
  toCppEnum (127) = ScriptAnatolianHieroglyphs
  toCppEnum (128) = ScriptHatran
  toCppEnum (129) = ScriptMultani
  toCppEnum (130) = ScriptOldHungarian
  toCppEnum (131) = ScriptSignWriting
  toCppEnum (132) = ScriptAdlam
  toCppEnum (133) = ScriptBhaiksuki
  toCppEnum (134) = ScriptMarchen
  toCppEnum (135) = ScriptNewa
  toCppEnum (136) = ScriptOsage
  toCppEnum (137) = ScriptTangut
  toCppEnum (138) = ScriptMasaramGondi
  toCppEnum (139) = ScriptNushu
  toCppEnum (140) = ScriptSoyombo
  toCppEnum (141) = ScriptZanabazarSquare
  toCppEnum n = UnknownQCharScript n

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

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

data QCharSpecialCharacter =
  Null
  | Tabulation
  | LineFeed
  | CarriageReturn
  | Space
  | Nbsp
  | SoftHyphen
  | ReplacementCharacter
  | ObjectReplacementCharacter
  | ByteOrderMark
  | ByteOrderSwapped
  | ParagraphSeparator
  | LineSeparator
  | LastValidCodePoint
  | UnknownQCharSpecialCharacter (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharSpecialCharacter where
  fromCppEnum Null = 0
  fromCppEnum Tabulation = 9
  fromCppEnum LineFeed = 10
  fromCppEnum CarriageReturn = 13
  fromCppEnum Space = 32
  fromCppEnum Nbsp = 160
  fromCppEnum SoftHyphen = 173
  fromCppEnum ReplacementCharacter = 65533
  fromCppEnum ObjectReplacementCharacter = 65532
  fromCppEnum ByteOrderMark = 65279
  fromCppEnum ByteOrderSwapped = 65534
  fromCppEnum ParagraphSeparator = 8233
  fromCppEnum LineSeparator = 8232
  fromCppEnum LastValidCodePoint = 1114111
  fromCppEnum (UnknownQCharSpecialCharacter n) = n
  
  toCppEnum (0) = Null
  toCppEnum (9) = Tabulation
  toCppEnum (10) = LineFeed
  toCppEnum (13) = CarriageReturn
  toCppEnum (32) = Space
  toCppEnum (160) = Nbsp
  toCppEnum (173) = SoftHyphen
  toCppEnum (8232) = LineSeparator
  toCppEnum (8233) = ParagraphSeparator
  toCppEnum (65279) = ByteOrderMark
  toCppEnum (65532) = ObjectReplacementCharacter
  toCppEnum (65533) = ReplacementCharacter
  toCppEnum (65534) = ByteOrderSwapped
  toCppEnum (1114111) = LastValidCodePoint
  toCppEnum n = UnknownQCharSpecialCharacter n

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

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

data QCharUnicodeVersion =
  Unicode11
  | Unicode20
  | Unicode212
  | Unicode30
  | Unicode31
  | Unicode32
  | Unicode40
  | Unicode41
  | Unicode50
  | Unicode51
  | Unicode52
  | Unicode60
  | Unicode61
  | Unicode62
  | Unicode63
  | Unicode70
  | Unicode80
  | Unicode90
  | Unicode100
  | UnicodeUnassigned
  | UnknownQCharUnicodeVersion (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QCharUnicodeVersion where
  fromCppEnum Unicode11 = 1
  fromCppEnum Unicode20 = 2
  fromCppEnum Unicode212 = 3
  fromCppEnum Unicode30 = 4
  fromCppEnum Unicode31 = 5
  fromCppEnum Unicode32 = 6
  fromCppEnum Unicode40 = 7
  fromCppEnum Unicode41 = 8
  fromCppEnum Unicode50 = 9
  fromCppEnum Unicode51 = 10
  fromCppEnum Unicode52 = 11
  fromCppEnum Unicode60 = 12
  fromCppEnum Unicode61 = 13
  fromCppEnum Unicode62 = 14
  fromCppEnum Unicode63 = 15
  fromCppEnum Unicode70 = 16
  fromCppEnum Unicode80 = 17
  fromCppEnum Unicode90 = 18
  fromCppEnum Unicode100 = 19
  fromCppEnum UnicodeUnassigned = 0
  fromCppEnum (UnknownQCharUnicodeVersion n) = n
  
  toCppEnum (0) = UnicodeUnassigned
  toCppEnum (1) = Unicode11
  toCppEnum (2) = Unicode20
  toCppEnum (3) = Unicode212
  toCppEnum (4) = Unicode30
  toCppEnum (5) = Unicode31
  toCppEnum (6) = Unicode32
  toCppEnum (7) = Unicode40
  toCppEnum (8) = Unicode41
  toCppEnum (9) = Unicode50
  toCppEnum (10) = Unicode51
  toCppEnum (11) = Unicode52
  toCppEnum (12) = Unicode60
  toCppEnum (13) = Unicode61
  toCppEnum (14) = Unicode62
  toCppEnum (15) = Unicode63
  toCppEnum (16) = Unicode70
  toCppEnum (17) = Unicode80
  toCppEnum (18) = Unicode90
  toCppEnum (19) = Unicode100
  toCppEnum n = UnknownQCharUnicodeVersion n

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

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