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

module Graphics.UI.Qtah.Generated.Core.QTextCodec (
  QTextCodecValue (..),
  QTextCodecConstPtr (..),
  aliases,
  canEncodeChar,
  canEncodeString,
  fromUnicode,
  mibEnum,
  name,
  toUnicode,
  QTextCodecPtr (..),
  availableCodecs,
  availableMibs,
  codecForHtml,
  codecForHtmlWithDefault,
  codecForLocale,
  codecForMib,
  codecForName,
  codecForUtfText,
  codecForUtfTextWithDefault,
  setCodecForLocale,
  QTextCodecConst (..),
  castQTextCodecToConst,
  QTextCodec (..),
  castQTextCodecToNonconst,
  QTextCodecSuper (..),
  QTextCodecSuperConst (..),
  ) where

import qualified Data.ByteString as QtahDBS
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.QList.Int as M192
import qualified Graphics.UI.Qtah.Generated.Core.QList.QByteArray as M196
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QTextCodec_aliases" aliases' ::  HoppyF.Ptr QTextCodecConst -> HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QTextCodec_canEncodeChar" canEncodeChar' ::  HoppyF.Ptr QTextCodecConst -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTextCodec_canEncodeString" canEncodeString' ::  HoppyF.Ptr QTextCodecConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTextCodec_fromUnicode" fromUnicode' ::  HoppyF.Ptr QTextCodecConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTextCodec_mibEnum" mibEnum' ::  HoppyF.Ptr QTextCodecConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QTextCodec_name" name' ::  HoppyF.Ptr QTextCodecConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QTextCodec_toUnicode" toUnicode' ::  HoppyF.Ptr QTextCodecConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTextCodec_availableCodecs" availableCodecs' ::  HoppyP.IO (HoppyF.Ptr M196.QListQByteArrayConst)
foreign import ccall "genpop__QTextCodec_availableMibs" availableMibs' ::  HoppyP.IO (HoppyF.Ptr M192.QListIntConst)
foreign import ccall "genpop__QTextCodec_codecForHtml" codecForHtml' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForHtmlWithDefault" codecForHtmlWithDefault' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyF.Ptr QTextCodec -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForLocale" codecForLocale' ::  HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForMib" codecForMib' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForName" codecForName' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForUtfText" codecForUtfText' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_codecForUtfTextWithDefault" codecForUtfTextWithDefault' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyF.Ptr QTextCodec -> HoppyP.IO (HoppyF.Ptr QTextCodec)
foreign import ccall "genpop__QTextCodec_setCodecForLocale" setCodecForLocale' ::  HoppyF.Ptr QTextCodec -> HoppyP.IO ()

class QTextCodecValue a where
  withQTextCodecPtr :: a -> (QTextCodecConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QTextCodecConstPtr a => QTextCodecValue a where
  withQTextCodecPtr = HoppyP.flip ($) . toQTextCodecConst

class (HoppyFHR.CppPtr this) => QTextCodecConstPtr this where
  toQTextCodecConst :: this -> QTextCodecConst

aliases :: (QTextCodecValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahDBS.ByteString])
aliases arg'1 =
  withQTextCodecPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (aliases' arg'1')

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

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

fromUnicode :: (QTextCodecValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahDBS.ByteString)
fromUnicode arg'1 arg'2 =
  withQTextCodecPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (fromUnicode' arg'1' arg'2')

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

name :: (QTextCodecValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
name arg'1 =
  withQTextCodecPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (name' arg'1')

toUnicode :: (QTextCodecValue this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
toUnicode arg'1 arg'2 =
  withQTextCodecPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toUnicode' arg'1' arg'2')

class (QTextCodecConstPtr this) => QTextCodecPtr this where
  toQTextCodec :: this -> QTextCodec

availableCodecs :: (HoppyP.IO [QtahDBS.ByteString])
availableCodecs =
  (HoppyFHR.decodeAndDelete . M196.QListQByteArrayConst) =<<
  (availableCodecs')

availableMibs :: (HoppyP.IO [HoppyP.Int])
availableMibs =
  (HoppyFHR.decodeAndDelete . M192.QListIntConst) =<<
  (availableMibs')

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

codecForHtmlWithDefault :: (M12.QByteArrayValue arg'1, QTextCodecPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QTextCodec)
codecForHtmlWithDefault arg'1 arg'2 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQTextCodec arg'2) $ \arg'2' ->
  HoppyP.fmap QTextCodec
  (codecForHtmlWithDefault' arg'1' arg'2')

codecForLocale :: (HoppyP.IO QTextCodec)
codecForLocale =
  HoppyP.fmap QTextCodec
  (codecForLocale')

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

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

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

codecForUtfTextWithDefault :: (M12.QByteArrayValue arg'1, QTextCodecPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QTextCodec)
codecForUtfTextWithDefault arg'1 arg'2 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQTextCodec arg'2) $ \arg'2' ->
  HoppyP.fmap QTextCodec
  (codecForUtfTextWithDefault' arg'1' arg'2')

setCodecForLocale :: (QTextCodecPtr arg'1) => (arg'1) -> (HoppyP.IO ())
setCodecForLocale arg'1 =
  HoppyFHR.withCppPtr (toQTextCodec arg'1) $ \arg'1' ->
  (setCodecForLocale' arg'1')

data QTextCodecConst =
    QTextCodecConst (HoppyF.Ptr QTextCodecConst)
  | QTextCodecConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTextCodecConst)
  deriving (HoppyP.Show)

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

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

castQTextCodecToConst :: QTextCodec -> QTextCodecConst
castQTextCodecToConst (QTextCodec ptr') = QTextCodecConst $ HoppyF.castPtr ptr'
castQTextCodecToConst (QTextCodecGc fptr' ptr') = QTextCodecConstGc fptr' $ HoppyF.castPtr ptr'

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

instance QTextCodecConstPtr QTextCodecConst where
  toQTextCodecConst = HoppyP.id

data QTextCodec =
    QTextCodec (HoppyF.Ptr QTextCodec)
  | QTextCodecGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTextCodec)
  deriving (HoppyP.Show)

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

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

castQTextCodecToNonconst :: QTextCodecConst -> QTextCodec
castQTextCodecToNonconst (QTextCodecConst ptr') = QTextCodec $ HoppyF.castPtr ptr'
castQTextCodecToNonconst (QTextCodecConstGc fptr' ptr') = QTextCodecGc fptr' $ HoppyF.castPtr ptr'

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

instance QTextCodecConstPtr QTextCodec where
  toQTextCodecConst (QTextCodec ptr') = QTextCodecConst $ (HoppyF.castPtr :: HoppyF.Ptr QTextCodec -> HoppyF.Ptr QTextCodecConst) ptr'
  toQTextCodecConst (QTextCodecGc fptr' ptr') = QTextCodecConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QTextCodec -> HoppyF.Ptr QTextCodecConst) ptr'

instance QTextCodecPtr QTextCodec where
  toQTextCodec = HoppyP.id

class QTextCodecSuper a where
  downToQTextCodec :: a -> QTextCodec


class QTextCodecSuperConst a where
  downToQTextCodecConst :: a -> QTextCodecConst


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

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