QLibrary.hs

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

module Graphics.UI.Qtah.Generated.Core.QLibrary (
  castQLibraryToQObject,
  castQObjectToQLibrary,
  QLibraryValue (..),
  QLibraryConstPtr (..),
  errorString,
  isLoaded,
  fileName,
  loadHints,
  QLibraryPtr (..),
  load,
  resolve,
  setFileNameAndMajorVersion,
  setFileNameAndVersion,
  unload,
  setFileName,
  setLoadHints,
  isLibrary,
  resolveStatic,
  resolveStaticWithMajorVersion,
  resolveStaticWithVersion,
  QLibraryConst (..),
  castQLibraryToConst,
  QLibrary (..),
  castQLibraryToNonconst,
  new,
  newWithParent,
  newWithFilename,
  newWithFilenameAndParent,
  newWithFilenameAndMajorVersion,
  newWithFilenameAndMajorVersionAndParent,
  newWithFilenameAndVersion,
  newWithFilenameAndVersionAndParent,
  QLibrarySuper (..),
  QLibrarySuperConst (..),
  QLibraryLoadHint (..),
  QLibraryLoadHints,
  IsQLibraryLoadHints (..),
  deepBindHint,
  exportExternalSymbolsHint,
  loadArchiveMemberHint,
  preventUnloadHint,
  resolveAllSymbolsHint,
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
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__QLibrary_new" new' ::  HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilename" newWithFilename' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilenameAndParent" newWithFilenameAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilenameAndMajorVersion" newWithFilenameAndMajorVersion' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilenameAndMajorVersionAndParent" newWithFilenameAndMajorVersionAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilenameAndVersion" newWithFilenameAndVersion' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_newWithFilenameAndVersionAndParent" newWithFilenameAndVersionAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QLibrary)
foreign import ccall "genpop__QLibrary_errorString" errorString' ::  HoppyF.Ptr QLibraryConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLibrary_isLibrary" isLibrary' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLibrary_isLoaded" isLoaded' ::  HoppyF.Ptr QLibraryConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLibrary_load" load' ::  HoppyF.Ptr QLibrary -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLibrary_resolve" resolve' ::  HoppyF.Ptr QLibrary -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
foreign import ccall "genpop__QLibrary_resolveStatic" resolveStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
foreign import ccall "genpop__QLibrary_resolveStaticWithMajorVersion" resolveStaticWithMajorVersion' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
foreign import ccall "genpop__QLibrary_resolveStaticWithVersion" resolveStaticWithVersion' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
foreign import ccall "genpop__QLibrary_setFileNameAndMajorVersion" setFileNameAndMajorVersion' ::  HoppyF.Ptr QLibrary -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLibrary_setFileNameAndVersion" setFileNameAndVersion' ::  HoppyF.Ptr QLibrary -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLibrary_unload" unload' ::  HoppyF.Ptr QLibrary -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLibrary_fileName" fileName' ::  HoppyF.Ptr QLibraryConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLibrary_setFileName" setFileName' ::  HoppyF.Ptr QLibrary -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLibrary_loadHints" loadHints' ::  HoppyF.Ptr QLibraryConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLibrary_setLoadHints" setLoadHints' ::  HoppyF.Ptr QLibrary -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QLibrary__QObject" castQLibraryToQObject :: HoppyF.Ptr QLibraryConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QLibrary" castQObjectToQLibrary :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QLibraryConst
foreign import ccall "gendel__QLibrary" delete'QLibrary :: HoppyF.Ptr QLibraryConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLibrary" deletePtr'QLibrary :: HoppyF.FunPtr (HoppyF.Ptr QLibraryConst -> HoppyP.IO ())

class QLibraryValue a where
  withQLibraryPtr :: a -> (QLibraryConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLibraryConstPtr a => QLibraryValue a where
  withQLibraryPtr = HoppyP.flip ($) . toQLibraryConst

class (M94.QObjectConstPtr this) => QLibraryConstPtr this where
  toQLibraryConst :: this -> QLibraryConst

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

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

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

loadHints :: (QLibraryValue this) => (this) {- ^ this -} -> (HoppyP.IO QLibraryLoadHints)
loadHints arg'1 =
  withQLibraryPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (loadHints' arg'1')

class (QLibraryConstPtr this, M94.QObjectPtr this) => QLibraryPtr this where
  toQLibrary :: this -> QLibrary

load :: (QLibraryPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
load arg'1 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (load' arg'1')

resolve :: (QLibraryPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ())))
resolve arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (resolve' arg'1' arg'2')

setFileNameAndMajorVersion :: (QLibraryPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
setFileNameAndMajorVersion arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setFileNameAndMajorVersion' arg'1' arg'2' arg'3')

setFileNameAndVersion :: (QLibraryPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setFileNameAndVersion arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setFileNameAndVersion' arg'1' arg'2' arg'3')

unload :: (QLibraryPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
unload arg'1 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (unload' arg'1')

setFileName :: (QLibraryPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFileName arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFileName' arg'1' arg'2')

setLoadHints :: (QLibraryPtr this, IsQLibraryLoadHints arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setLoadHints arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLibrary arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQLibraryLoadHints
  ) arg'2 >>= \arg'2' ->
  (setLoadHints' arg'1' arg'2')

isLibrary :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
isLibrary arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isLibrary' arg'1')

resolveStatic :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ())))
resolveStatic arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (resolveStatic' arg'1' arg'2')

resolveStaticWithMajorVersion :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ())))
resolveStaticWithMajorVersion arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (resolveStaticWithMajorVersion' arg'1' arg'2' arg'3')

resolveStaticWithVersion :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ())))
resolveStaticWithVersion arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  let arg'3' = arg'3 in
  (resolveStaticWithVersion' arg'1' arg'2' arg'3')

data QLibraryConst =
    QLibraryConst (HoppyF.Ptr QLibraryConst)
  | QLibraryConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLibraryConst)
  deriving (HoppyP.Show)

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

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

castQLibraryToConst :: QLibrary -> QLibraryConst
castQLibraryToConst (QLibrary ptr') = QLibraryConst $ HoppyF.castPtr ptr'
castQLibraryToConst (QLibraryGc fptr' ptr') = QLibraryConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLibraryConstPtr QLibraryConst where
  toQLibraryConst = HoppyP.id

instance M94.QObjectConstPtr QLibraryConst where
  toQObjectConst (QLibraryConst ptr') = M94.QObjectConst $ castQLibraryToQObject ptr'
  toQObjectConst (QLibraryConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLibraryToQObject ptr'

data QLibrary =
    QLibrary (HoppyF.Ptr QLibrary)
  | QLibraryGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLibrary)
  deriving (HoppyP.Show)

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

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

castQLibraryToNonconst :: QLibraryConst -> QLibrary
castQLibraryToNonconst (QLibraryConst ptr') = QLibrary $ HoppyF.castPtr ptr'
castQLibraryToNonconst (QLibraryConstGc fptr' ptr') = QLibraryGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLibraryConstPtr QLibrary where
  toQLibraryConst (QLibrary ptr') = QLibraryConst $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'
  toQLibraryConst (QLibraryGc fptr' ptr') = QLibraryConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'

instance QLibraryPtr QLibrary where
  toQLibrary = HoppyP.id

instance M94.QObjectConstPtr QLibrary where
  toQObjectConst (QLibrary ptr') = M94.QObjectConst $ castQLibraryToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'
  toQObjectConst (QLibraryGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLibraryToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'

instance M94.QObjectPtr QLibrary where
  toQObject (QLibrary ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLibraryToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'
  toQObject (QLibraryGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLibraryToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLibrary -> HoppyF.Ptr QLibraryConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QLibrary)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QLibrary
  (newWithParent' arg'1')

newWithFilename :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QLibrary)
newWithFilename arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QLibrary
  (newWithFilename' arg'1')

newWithFilenameAndParent :: (M142.QStringValue arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QLibrary)
newWithFilenameAndParent arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QLibrary
  (newWithFilenameAndParent' arg'1' arg'2')

newWithFilenameAndMajorVersion :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.Int) -> (HoppyP.IO QLibrary)
newWithFilenameAndMajorVersion arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QLibrary
  (newWithFilenameAndMajorVersion' arg'1' arg'2')

newWithFilenameAndMajorVersionAndParent :: (M142.QStringValue arg'1, M94.QObjectPtr arg'3) => (arg'1) -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QLibrary)
newWithFilenameAndMajorVersionAndParent arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'3) $ \arg'3' ->
  HoppyP.fmap QLibrary
  (newWithFilenameAndMajorVersionAndParent' arg'1' arg'2' arg'3')

newWithFilenameAndVersion :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QLibrary)
newWithFilenameAndVersion arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QLibrary
  (newWithFilenameAndVersion' arg'1' arg'2')

newWithFilenameAndVersionAndParent :: (M142.QStringValue arg'1, M142.QStringValue arg'2, M94.QObjectPtr arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QLibrary)
newWithFilenameAndVersionAndParent arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'3) $ \arg'3' ->
  HoppyP.fmap QLibrary
  (newWithFilenameAndVersionAndParent' arg'1' arg'2' arg'3')

class QLibrarySuper a where
  downToQLibrary :: a -> QLibrary

instance QLibrarySuper M94.QObject where
  downToQLibrary = castQLibraryToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QLibraryConst $ castQObjectToQLibrary ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLibraryConstGc fptr' $ castQObjectToQLibrary ptr'

class QLibrarySuperConst a where
  downToQLibraryConst :: a -> QLibraryConst

instance QLibrarySuperConst M94.QObjectConst where
  downToQLibraryConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QLibraryConst $ castQObjectToQLibrary ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLibraryConstGc fptr' $ castQObjectToQLibrary ptr'

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

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

data QLibraryLoadHint =
  ResolveAllSymbolsHint
  | ExportExternalSymbolsHint
  | LoadArchiveMemberHint
  | PreventUnloadHint
  | DeepBindHint
  | UnknownQLibraryLoadHint (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLibraryLoadHint where
  fromCppEnum ResolveAllSymbolsHint = 1
  fromCppEnum ExportExternalSymbolsHint = 2
  fromCppEnum LoadArchiveMemberHint = 4
  fromCppEnum PreventUnloadHint = 8
  fromCppEnum DeepBindHint = 16
  fromCppEnum (UnknownQLibraryLoadHint n) = n
  
  toCppEnum (1) = ResolveAllSymbolsHint
  toCppEnum (2) = ExportExternalSymbolsHint
  toCppEnum (4) = LoadArchiveMemberHint
  toCppEnum (8) = PreventUnloadHint
  toCppEnum (16) = DeepBindHint
  toCppEnum n = UnknownQLibraryLoadHint n

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

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

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

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

class IsQLibraryLoadHints a where
  toQLibraryLoadHints :: a -> QLibraryLoadHints

instance IsQLibraryLoadHints QLibraryLoadHints where toQLibraryLoadHints = QtahP.id
instance IsQLibraryLoadHints QLibraryLoadHint where toQLibraryLoadHints = QtahFlags.enumToFlags
instance IsQLibraryLoadHints (HoppyFC.CInt) where toQLibraryLoadHints = QtahFlags.numToFlags

deepBindHint :: QLibraryLoadHints
deepBindHint = QLibraryLoadHints (16)

exportExternalSymbolsHint :: QLibraryLoadHints
exportExternalSymbolsHint = QLibraryLoadHints (2)

loadArchiveMemberHint :: QLibraryLoadHints
loadArchiveMemberHint = QLibraryLoadHints (4)

preventUnloadHint :: QLibraryLoadHints
preventUnloadHint = QLibraryLoadHints (8)

resolveAllSymbolsHint :: QLibraryLoadHints
resolveAllSymbolsHint = QLibraryLoadHints (1)

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