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

module Graphics.UI.Qtah.Generated.Core.QLockFile (
  QLockFileValue (..),
  QLockFileConstPtr (..),
  error,
  getLockInfo,
  isLocked,
  staleLockTime,
  QLockFilePtr (..),
  lock,
  removeStaleLockFile,
  setStaleLockTime,
  tryLock,
  tryLockWithTimeout,
  unlock,
  QLockFileConst (..),
  castQLockFileToConst,
  QLockFile (..),
  castQLockFileToNonconst,
  new,
  QLockFileSuper (..),
  QLockFileSuperConst (..),
  QLockFileLockError (..),
  ) 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.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QLockFile_new" new' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QLockFile)
foreign import ccall "genpop__QLockFile_error" error' ::  HoppyF.Ptr QLockFileConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLockFile_getLockInfo" getLockInfo' ::  HoppyF.Ptr QLockFileConst -> HoppyF.Ptr HoppyFC.CLLong -> HoppyF.Ptr M142.QString -> HoppyF.Ptr M142.QString -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_isLocked" isLocked' ::  HoppyF.Ptr QLockFileConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_lock" lock' ::  HoppyF.Ptr QLockFile -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_removeStaleLockFile" removeStaleLockFile' ::  HoppyF.Ptr QLockFile -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_setStaleLockTime" setStaleLockTime' ::  HoppyF.Ptr QLockFile -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLockFile_staleLockTime" staleLockTime' ::  HoppyF.Ptr QLockFileConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLockFile_tryLock" tryLock' ::  HoppyF.Ptr QLockFile -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_tryLockWithTimeout" tryLockWithTimeout' ::  HoppyF.Ptr QLockFile -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLockFile_unlock" unlock' ::  HoppyF.Ptr QLockFile -> HoppyP.IO ()
foreign import ccall "gendel__QLockFile" delete'QLockFile :: HoppyF.Ptr QLockFileConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLockFile" deletePtr'QLockFile :: HoppyF.FunPtr (HoppyF.Ptr QLockFileConst -> HoppyP.IO ())

class QLockFileValue a where
  withQLockFilePtr :: a -> (QLockFileConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLockFileConstPtr a => QLockFileValue a where
  withQLockFilePtr = HoppyP.flip ($) . toQLockFileConst

class (HoppyFHR.CppPtr this) => QLockFileConstPtr this where
  toQLockFileConst :: this -> QLockFileConst

error :: (QLockFileValue this) => (this) {- ^ this -} -> (HoppyP.IO QLockFileLockError)
error arg'1 =
  withQLockFilePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (error' arg'1')

getLockInfo :: (QLockFileValue this, M142.QStringPtr arg'3, M142.QStringPtr arg'4) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CLLong) -> (arg'3) -> (arg'4) -> (HoppyP.IO HoppyP.Bool)
getLockInfo arg'1 arg'2 arg'3 arg'4 =
  withQLockFilePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyFHR.withCppPtr (M142.toQString arg'3) $ \arg'3' ->
  HoppyFHR.withCppPtr (M142.toQString arg'4) $ \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (getLockInfo' arg'1' arg'2' arg'3' arg'4')

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

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

class (QLockFileConstPtr this) => QLockFilePtr this where
  toQLockFile :: this -> QLockFile

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

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

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

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

tryLockWithTimeout :: (QLockFilePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
tryLockWithTimeout arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLockFile arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (tryLockWithTimeout' arg'1' arg'2')

unlock :: (QLockFilePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unlock arg'1 =
  HoppyFHR.withCppPtr (toQLockFile arg'1) $ \arg'1' ->
  (unlock' arg'1')

data QLockFileConst =
    QLockFileConst (HoppyF.Ptr QLockFileConst)
  | QLockFileConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLockFileConst)
  deriving (HoppyP.Show)

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

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

castQLockFileToConst :: QLockFile -> QLockFileConst
castQLockFileToConst (QLockFile ptr') = QLockFileConst $ HoppyF.castPtr ptr'
castQLockFileToConst (QLockFileGc fptr' ptr') = QLockFileConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLockFileConstPtr QLockFileConst where
  toQLockFileConst = HoppyP.id

data QLockFile =
    QLockFile (HoppyF.Ptr QLockFile)
  | QLockFileGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLockFile)
  deriving (HoppyP.Show)

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

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

castQLockFileToNonconst :: QLockFileConst -> QLockFile
castQLockFileToNonconst (QLockFileConst ptr') = QLockFile $ HoppyF.castPtr ptr'
castQLockFileToNonconst (QLockFileConstGc fptr' ptr') = QLockFileGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLockFileConstPtr QLockFile where
  toQLockFileConst (QLockFile ptr') = QLockFileConst $ (HoppyF.castPtr :: HoppyF.Ptr QLockFile -> HoppyF.Ptr QLockFileConst) ptr'
  toQLockFileConst (QLockFileGc fptr' ptr') = QLockFileConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLockFile -> HoppyF.Ptr QLockFileConst) ptr'

instance QLockFilePtr QLockFile where
  toQLockFile = HoppyP.id

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

class QLockFileSuper a where
  downToQLockFile :: a -> QLockFile


class QLockFileSuperConst a where
  downToQLockFileConst :: a -> QLockFileConst


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

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

data QLockFileLockError =
  NoError
  | LockFailedError
  | PermissionError
  | UnknownError
  | UnknownQLockFileLockError (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLockFileLockError where
  fromCppEnum NoError = 0
  fromCppEnum LockFailedError = 1
  fromCppEnum PermissionError = 2
  fromCppEnum UnknownError = 3
  fromCppEnum (UnknownQLockFileLockError n) = n
  
  toCppEnum (0) = NoError
  toCppEnum (1) = LockFailedError
  toCppEnum (2) = PermissionError
  toCppEnum (3) = UnknownError
  toCppEnum n = UnknownQLockFileLockError n

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

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