QBuffer.hs

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

module Graphics.UI.Qtah.Generated.Core.QBuffer (
  castQBufferToQIODevice,
  castQIODeviceToQBuffer,
  castQBufferToQObject,
  castQObjectToQBuffer,
  QBufferValue (..),
  QBufferConstPtr (..),
  bufferConst,
  getData,
  QBufferPtr (..),
  buffer,
  setBuffer,
  setDataByteArray,
  setDataRaw,
  QBufferConst (..),
  castQBufferToConst,
  QBuffer (..),
  castQBufferToNonconst,
  new,
  newWithParent,
  newWithByteArray,
  newWithByteArrayAndParent,
  QBufferSuper (..),
  QBufferSuperConst (..),
  ) where

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.QIODevice as M48
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import Prelude (($), (.), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QBuffer_new" new' ::  HoppyP.IO (HoppyF.Ptr QBuffer)
foreign import ccall "genpop__QBuffer_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QBuffer)
foreign import ccall "genpop__QBuffer_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArray -> HoppyP.IO (HoppyF.Ptr QBuffer)
foreign import ccall "genpop__QBuffer_newWithByteArrayAndParent" newWithByteArrayAndParent' ::  HoppyF.Ptr M12.QByteArray -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QBuffer)
foreign import ccall "genpop__QBuffer_buffer" buffer' ::  HoppyF.Ptr QBuffer -> HoppyP.IO (HoppyF.Ptr M12.QByteArray)
foreign import ccall "genpop__QBuffer_bufferConst" bufferConst' ::  HoppyF.Ptr QBufferConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QBuffer_getData" getData' ::  HoppyF.Ptr QBufferConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QBuffer_setBuffer" setBuffer' ::  HoppyF.Ptr QBuffer -> HoppyF.Ptr M12.QByteArray -> HoppyP.IO ()
foreign import ccall "genpop__QBuffer_setDataByteArray" setDataByteArray' ::  HoppyF.Ptr QBuffer -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QBuffer_setDataRaw" setDataRaw' ::  HoppyF.Ptr QBuffer -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QBuffer__QIODevice" castQBufferToQIODevice :: HoppyF.Ptr QBufferConst -> HoppyF.Ptr M48.QIODeviceConst
foreign import ccall "gencast__QIODevice__QBuffer" castQIODeviceToQBuffer :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr QBufferConst
foreign import ccall "gencast__QBuffer__QObject" castQBufferToQObject :: HoppyF.Ptr QBufferConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QBuffer" castQObjectToQBuffer :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QBufferConst
foreign import ccall "gendel__QBuffer" delete'QBuffer :: HoppyF.Ptr QBufferConst -> HoppyP.IO ()
foreign import ccall "&gendel__QBuffer" deletePtr'QBuffer :: HoppyF.FunPtr (HoppyF.Ptr QBufferConst -> HoppyP.IO ())

class QBufferValue a where
  withQBufferPtr :: a -> (QBufferConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QBufferConstPtr a => QBufferValue a where
  withQBufferPtr = HoppyP.flip ($) . toQBufferConst

class (M48.QIODeviceConstPtr this) => QBufferConstPtr this where
  toQBufferConst :: this -> QBufferConst

bufferConst :: (QBufferValue this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArrayConst)
bufferConst arg'1 =
  withQBufferPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M12.QByteArrayConst
  (bufferConst' arg'1')

getData :: (QBufferValue this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArrayConst)
getData arg'1 =
  withQBufferPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M12.QByteArrayConst
  (getData' arg'1')

class (QBufferConstPtr this, M48.QIODevicePtr this) => QBufferPtr this where
  toQBuffer :: this -> QBuffer

buffer :: (QBufferPtr this) => (this) {- ^ this -} -> (HoppyP.IO M12.QByteArray)
buffer arg'1 =
  HoppyFHR.withCppPtr (toQBuffer arg'1) $ \arg'1' ->
  HoppyP.fmap M12.QByteArray
  (buffer' arg'1')

setBuffer :: (QBufferPtr this, M12.QByteArrayPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setBuffer arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBuffer arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M12.toQByteArray arg'2) $ \arg'2' ->
  (setBuffer' arg'1' arg'2')

setDataByteArray :: (QBufferPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setDataByteArray arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBuffer arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setDataByteArray' arg'1' arg'2')

setDataRaw :: (QBufferPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO ())
setDataRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQBuffer arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setDataRaw' arg'1' arg'2' arg'3')

data QBufferConst =
    QBufferConst (HoppyF.Ptr QBufferConst)
  | QBufferConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBufferConst)
  deriving (HoppyP.Show)

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

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

castQBufferToConst :: QBuffer -> QBufferConst
castQBufferToConst (QBuffer ptr') = QBufferConst $ HoppyF.castPtr ptr'
castQBufferToConst (QBufferGc fptr' ptr') = QBufferConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QBufferConstPtr QBufferConst where
  toQBufferConst = HoppyP.id

instance M48.QIODeviceConstPtr QBufferConst where
  toQIODeviceConst (QBufferConst ptr') = M48.QIODeviceConst $ castQBufferToQIODevice ptr'
  toQIODeviceConst (QBufferConstGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQBufferToQIODevice ptr'

instance M94.QObjectConstPtr QBufferConst where
  toQObjectConst (QBufferConst ptr') = M94.QObjectConst $ castQBufferToQObject ptr'
  toQObjectConst (QBufferConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQBufferToQObject ptr'

data QBuffer =
    QBuffer (HoppyF.Ptr QBuffer)
  | QBufferGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBuffer)
  deriving (HoppyP.Show)

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

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

castQBufferToNonconst :: QBufferConst -> QBuffer
castQBufferToNonconst (QBufferConst ptr') = QBuffer $ HoppyF.castPtr ptr'
castQBufferToNonconst (QBufferConstGc fptr' ptr') = QBufferGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QBufferConstPtr QBuffer where
  toQBufferConst (QBuffer ptr') = QBufferConst $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'
  toQBufferConst (QBufferGc fptr' ptr') = QBufferConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'

instance QBufferPtr QBuffer where
  toQBuffer = HoppyP.id

instance M48.QIODeviceConstPtr QBuffer where
  toQIODeviceConst (QBuffer ptr') = M48.QIODeviceConst $ castQBufferToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'
  toQIODeviceConst (QBufferGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQBufferToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'

instance M48.QIODevicePtr QBuffer where
  toQIODevice (QBuffer ptr') = M48.QIODevice $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQBufferToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'
  toQIODevice (QBufferGc fptr' ptr') = M48.QIODeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQBufferToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'

instance M94.QObjectConstPtr QBuffer where
  toQObjectConst (QBuffer ptr') = M94.QObjectConst $ castQBufferToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'
  toQObjectConst (QBufferGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQBufferToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'

instance M94.QObjectPtr QBuffer where
  toQObject (QBuffer ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQBufferToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'
  toQObject (QBufferGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQBufferToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QBuffer -> HoppyF.Ptr QBufferConst) ptr'

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

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

newWithByteArray :: (M12.QByteArrayPtr arg'1) => (arg'1) -> (HoppyP.IO QBuffer)
newWithByteArray arg'1 =
  HoppyFHR.withCppPtr (M12.toQByteArray arg'1) $ \arg'1' ->
  HoppyP.fmap QBuffer
  (newWithByteArray' arg'1')

newWithByteArrayAndParent :: (M12.QByteArrayPtr arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QBuffer)
newWithByteArrayAndParent arg'1 arg'2 =
  HoppyFHR.withCppPtr (M12.toQByteArray arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QBuffer
  (newWithByteArrayAndParent' arg'1' arg'2')

class QBufferSuper a where
  downToQBuffer :: a -> QBuffer

instance QBufferSuper M48.QIODevice where
  downToQBuffer = castQBufferToNonconst . cast' . M48.castQIODeviceToConst
    where
      cast' (M48.QIODeviceConst ptr') = QBufferConst $ castQIODeviceToQBuffer ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QBufferConstGc fptr' $ castQIODeviceToQBuffer ptr'
instance QBufferSuper M94.QObject where
  downToQBuffer = castQBufferToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QBufferConst $ castQObjectToQBuffer ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QBufferConstGc fptr' $ castQObjectToQBuffer ptr'

class QBufferSuperConst a where
  downToQBufferConst :: a -> QBufferConst

instance QBufferSuperConst M48.QIODeviceConst where
  downToQBufferConst = cast'
    where
      cast' (M48.QIODeviceConst ptr') = QBufferConst $ castQIODeviceToQBuffer ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QBufferConstGc fptr' $ castQIODeviceToQBuffer ptr'
instance QBufferSuperConst M94.QObjectConst where
  downToQBufferConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QBufferConst $ castQObjectToQBuffer ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QBufferConstGc fptr' $ castQObjectToQBuffer ptr'

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

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