QDirIterator.hs

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

module Graphics.UI.Qtah.Generated.Core.QDirIterator (
  QDirIteratorValue (..),
  QDirIteratorConstPtr (..),
  fileName,
  filePath,
  hasNext,
  path,
  QDirIteratorPtr (..),
  next,
  QDirIteratorConst (..),
  castQDirIteratorToConst,
  QDirIterator (..),
  castQDirIteratorToNonconst,
  new,
  newWithDirAndFlags,
  newWithString,
  newWithStringAndFlags,
  newWithStringAndFilters,
  newWithStringAndFiltersAndFlags,
  newWithStringAndStringList,
  newWithStringAndStringListAndFilters,
  newWithStringAndStringListAndFiltersAndFlags,
  QDirIteratorSuper (..),
  QDirIteratorSuperConst (..),
  QDirIteratorIteratorFlag (..),
  QDirIteratorIteratorFlags,
  IsQDirIteratorIteratorFlags (..),
  followSymlinks,
  noIteratorFlags,
  subdirectories,
  ) 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.QDir as M30
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QDirIterator_new" new' ::  HoppyF.Ptr M30.QDirConst -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithDirAndFlags" newWithDirAndFlags' ::  HoppyF.Ptr M30.QDirConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithString" newWithString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndFlags" newWithStringAndFlags' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndFilters" newWithStringAndFilters' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndFiltersAndFlags" newWithStringAndFiltersAndFlags' ::  HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndStringList" newWithStringAndStringList' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndStringListAndFilters" newWithStringAndStringListAndFilters' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_newWithStringAndStringListAndFiltersAndFlags" newWithStringAndStringListAndFiltersAndFlags' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDirIterator)
foreign import ccall "genpop__QDirIterator_fileName" fileName' ::  HoppyF.Ptr QDirIteratorConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDirIterator_filePath" filePath' ::  HoppyF.Ptr QDirIteratorConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDirIterator_hasNext" hasNext' ::  HoppyF.Ptr QDirIteratorConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDirIterator_next" next' ::  HoppyF.Ptr QDirIterator -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDirIterator_path" path' ::  HoppyF.Ptr QDirIteratorConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gendel__QDirIterator" delete'QDirIterator :: HoppyF.Ptr QDirIteratorConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDirIterator" deletePtr'QDirIterator :: HoppyF.FunPtr (HoppyF.Ptr QDirIteratorConst -> HoppyP.IO ())

class QDirIteratorValue a where
  withQDirIteratorPtr :: a -> (QDirIteratorConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDirIteratorConstPtr a => QDirIteratorValue a where
  withQDirIteratorPtr = HoppyP.flip ($) . toQDirIteratorConst

class (HoppyFHR.CppPtr this) => QDirIteratorConstPtr this where
  toQDirIteratorConst :: this -> QDirIteratorConst

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

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

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

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

class (QDirIteratorConstPtr this) => QDirIteratorPtr this where
  toQDirIterator :: this -> QDirIterator

next :: (QDirIteratorPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
next arg'1 =
  HoppyFHR.withCppPtr (toQDirIterator arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (next' arg'1')

data QDirIteratorConst =
    QDirIteratorConst (HoppyF.Ptr QDirIteratorConst)
  | QDirIteratorConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDirIteratorConst)
  deriving (HoppyP.Show)

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

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

castQDirIteratorToConst :: QDirIterator -> QDirIteratorConst
castQDirIteratorToConst (QDirIterator ptr') = QDirIteratorConst $ HoppyF.castPtr ptr'
castQDirIteratorToConst (QDirIteratorGc fptr' ptr') = QDirIteratorConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDirIteratorConstPtr QDirIteratorConst where
  toQDirIteratorConst = HoppyP.id

data QDirIterator =
    QDirIterator (HoppyF.Ptr QDirIterator)
  | QDirIteratorGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDirIterator)
  deriving (HoppyP.Show)

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

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

castQDirIteratorToNonconst :: QDirIteratorConst -> QDirIterator
castQDirIteratorToNonconst (QDirIteratorConst ptr') = QDirIterator $ HoppyF.castPtr ptr'
castQDirIteratorToNonconst (QDirIteratorConstGc fptr' ptr') = QDirIteratorGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDirIteratorConstPtr QDirIterator where
  toQDirIteratorConst (QDirIterator ptr') = QDirIteratorConst $ (HoppyF.castPtr :: HoppyF.Ptr QDirIterator -> HoppyF.Ptr QDirIteratorConst) ptr'
  toQDirIteratorConst (QDirIteratorGc fptr' ptr') = QDirIteratorConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDirIterator -> HoppyF.Ptr QDirIteratorConst) ptr'

instance QDirIteratorPtr QDirIterator where
  toQDirIterator = HoppyP.id

new :: (M30.QDirValue arg'1) => (arg'1) -> (HoppyP.IO QDirIterator)
new arg'1 =
  M30.withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QDirIterator
  (new' arg'1')

newWithDirAndFlags :: (M30.QDirValue arg'1, IsQDirIteratorIteratorFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDirIterator)
newWithDirAndFlags arg'1 arg'2 =
  M30.withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirIteratorIteratorFlags
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QDirIterator
  (newWithDirAndFlags' arg'1' arg'2')

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

newWithStringAndFlags :: (M142.QStringValue arg'1, IsQDirIteratorIteratorFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDirIterator)
newWithStringAndFlags arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirIteratorIteratorFlags
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndFlags' arg'1' arg'2')

newWithStringAndFilters :: (M142.QStringValue arg'1, M30.IsQDirFilters arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDirIterator)
newWithStringAndFilters arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M30.toQDirFilters
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndFilters' arg'1' arg'2')

newWithStringAndFiltersAndFlags :: (M142.QStringValue arg'1, M30.IsQDirFilters arg'2, IsQDirIteratorIteratorFlags arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QDirIterator)
newWithStringAndFiltersAndFlags arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M30.toQDirFilters
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirIteratorIteratorFlags
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndFiltersAndFlags' arg'1' arg'2' arg'3')

newWithStringAndStringList :: (M142.QStringValue arg'1, M144.QStringListValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QDirIterator)
newWithStringAndStringList arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndStringList' arg'1' arg'2')

newWithStringAndStringListAndFilters :: (M142.QStringValue arg'1, M144.QStringListValue arg'2, M30.IsQDirFilters arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QDirIterator)
newWithStringAndStringListAndFilters arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M30.toQDirFilters
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndStringListAndFilters' arg'1' arg'2' arg'3')

newWithStringAndStringListAndFiltersAndFlags :: (M142.QStringValue arg'1, M144.QStringListValue arg'2, M30.IsQDirFilters arg'3, IsQDirIteratorIteratorFlags arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO QDirIterator)
newWithStringAndStringListAndFiltersAndFlags arg'1 arg'2 arg'3 arg'4 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M30.toQDirFilters
  ) arg'3 >>= \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirIteratorIteratorFlags
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QDirIterator
  (newWithStringAndStringListAndFiltersAndFlags' arg'1' arg'2' arg'3' arg'4')

class QDirIteratorSuper a where
  downToQDirIterator :: a -> QDirIterator


class QDirIteratorSuperConst a where
  downToQDirIteratorConst :: a -> QDirIteratorConst


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

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

data QDirIteratorIteratorFlag =
  NoIteratorFlags
  | Subdirectories
  | FollowSymlinks
  | UnknownQDirIteratorIteratorFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QDirIteratorIteratorFlag where
  fromCppEnum NoIteratorFlags = 0
  fromCppEnum Subdirectories = 2
  fromCppEnum FollowSymlinks = 1
  fromCppEnum (UnknownQDirIteratorIteratorFlag n) = n
  
  toCppEnum (0) = NoIteratorFlags
  toCppEnum (1) = FollowSymlinks
  toCppEnum (2) = Subdirectories
  toCppEnum n = UnknownQDirIteratorIteratorFlag n

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

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

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

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

class IsQDirIteratorIteratorFlags a where
  toQDirIteratorIteratorFlags :: a -> QDirIteratorIteratorFlags

instance IsQDirIteratorIteratorFlags QDirIteratorIteratorFlags where toQDirIteratorIteratorFlags = QtahP.id
instance IsQDirIteratorIteratorFlags QDirIteratorIteratorFlag where toQDirIteratorIteratorFlags = QtahFlags.enumToFlags
instance IsQDirIteratorIteratorFlags (HoppyFC.CInt) where toQDirIteratorIteratorFlags = QtahFlags.numToFlags

followSymlinks :: QDirIteratorIteratorFlags
followSymlinks = QDirIteratorIteratorFlags (1)

noIteratorFlags :: QDirIteratorIteratorFlags
noIteratorFlags = QDirIteratorIteratorFlags (0)

subdirectories :: QDirIteratorIteratorFlags
subdirectories = QDirIteratorIteratorFlags (2)

instance QtahDB.Bits QDirIteratorIteratorFlags 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