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

module Graphics.UI.Qtah.Generated.Core.QDir (
  QDirValue (..),
  QDirConstPtr (..),
  absoluteFilePath,
  absolutePath,
  canonicalPath,
  count,
  dirName,
  exists,
  entryExists,
  filePath,
  filter,
  isAbsolute,
  isReadable,
  isRelative,
  isRoot,
  mkdir,
  mkpath,
  path,
  relativeFilePath,
  rmdir,
  rmpath,
  sorting,
  aRRAY,
  eQ,
  nE,
  QDirPtr (..),
  cd,
  cdUp,
  setFilter,
  makeAbsolute,
  setPath,
  refresh,
  remove,
  removeRecursively,
  rename,
  setSorting,
  swap,
  aSSIGN,
  addSearchPath,
  cleanPath,
  current,
  currentPath,
  fromNativeSeparators,
  home,
  homePath,
  isAbsolutePath,
  isRelativePath,
  match,
  root,
  rootPath,
  separator,
  setCurrent,
  temp,
  tempPath,
  toNativeSeparators,
  QDirConst (..),
  castQDirToConst,
  QDir (..),
  castQDirToNonconst,
  new,
  newCopy,
  QDirSuper (..),
  QDirSuperConst (..),
  QDirFilter (..),
  QDirFilters,
  IsQDirFilters (..),
  allDirs,
  allEntries,
  caseSensitive,
  dirs,
  drives,
  executable,
  files,
  hidden,
  modified,
  noDot,
  noDotAndDotDot,
  noDotDot,
  noSymLinks,
  readable,
  system,
  writable,
  QDirSortFlag (..),
  QDirSortFlags,
  IsQDirSortFlags (..),
  dirsFirst,
  dirsLast,
  ignoreCase,
  localeAware,
  name,
  noSort,
  reversed,
  size,
  time,
  typ,
  unsorted,
  ) where

import Control.Monad ((>=>))
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.QChar as M16
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__QDir_new" new' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QDir)
foreign import ccall "genpop__QDir_newCopy" newCopy' ::  HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr QDir)
foreign import ccall "genpop__QDir_absoluteFilePath" absoluteFilePath' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_absolutePath" absolutePath' ::  HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_addSearchPath" addSearchPath' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QDir_canonicalPath" canonicalPath' ::  HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_cd" cd' ::  HoppyF.Ptr QDir -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_cdUp" cdUp' ::  HoppyF.Ptr QDir -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_cleanPath" cleanPath' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_count" count' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDir_current" current' ::  HoppyP.IO (HoppyF.Ptr QDirConst)
foreign import ccall "genpop__QDir_currentPath" currentPath' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_dirName" dirName' ::  HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_exists" exists' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_entryExists" entryExists' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_filePath" filePath' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_filter" filter' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDir_setFilter" setFilter' ::  HoppyF.Ptr QDir -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDir_fromNativeSeparators" fromNativeSeparators' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_home" home' ::  HoppyP.IO (HoppyF.Ptr QDirConst)
foreign import ccall "genpop__QDir_homePath" homePath' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_isAbsolute" isAbsolute' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_isAbsolutePath" isAbsolutePath' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_isReadable" isReadable' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_isRelative" isRelative' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_isRelativePath" isRelativePath' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_isRoot" isRoot' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_makeAbsolute" makeAbsolute' ::  HoppyF.Ptr QDir -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_match" match' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_mkdir" mkdir' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_mkpath" mkpath' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_path" path' ::  HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_setPath" setPath' ::  HoppyF.Ptr QDir -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QDir_refresh" refresh' ::  HoppyF.Ptr QDir -> HoppyP.IO ()
foreign import ccall "genpop__QDir_relativeFilePath" relativeFilePath' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_remove" remove' ::  HoppyF.Ptr QDir -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_removeRecursively" removeRecursively' ::  HoppyF.Ptr QDir -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_rename" rename' ::  HoppyF.Ptr QDir -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_rmdir" rmdir' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_rmpath" rmpath' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_root" root' ::  HoppyP.IO (HoppyF.Ptr QDirConst)
foreign import ccall "genpop__QDir_rootPath" rootPath' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_separator" separator' ::  HoppyP.IO (HoppyF.Ptr M16.QCharConst)
foreign import ccall "genpop__QDir_setCurrent" setCurrent' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_sorting" sorting' ::  HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDir_setSorting" setSorting' ::  HoppyF.Ptr QDir -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDir_swap" swap' ::  HoppyF.Ptr QDir -> HoppyF.Ptr QDir -> HoppyP.IO ()
foreign import ccall "genpop__QDir_temp" temp' ::  HoppyP.IO (HoppyF.Ptr QDirConst)
foreign import ccall "genpop__QDir_tempPath" tempPath' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_toNativeSeparators" toNativeSeparators' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_ARRAY" aRRAY' ::  HoppyF.Ptr QDirConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDir_EQ" eQ' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_NE" nE' ::  HoppyF.Ptr QDirConst -> HoppyF.Ptr QDirConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDir_ASSIGN" aSSIGN' ::  HoppyF.Ptr QDir -> HoppyF.Ptr QDirConst -> HoppyP.IO (HoppyF.Ptr QDir)
foreign import ccall "gendel__QDir" delete'QDir :: HoppyF.Ptr QDirConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDir" deletePtr'QDir :: HoppyF.FunPtr (HoppyF.Ptr QDirConst -> HoppyP.IO ())

class QDirValue a where
  withQDirPtr :: a -> (QDirConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDirConstPtr a => QDirValue a where
  withQDirPtr = HoppyP.flip ($) . toQDirConst

class (HoppyFHR.CppPtr this) => QDirConstPtr this where
  toQDirConst :: this -> QDirConst

absoluteFilePath :: (QDirValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
absoluteFilePath arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (absoluteFilePath' arg'1' arg'2')

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

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

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

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

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

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

filePath :: (QDirValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
filePath arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (filePath' arg'1' arg'2')

filter :: (QDirValue this) => (this) {- ^ this -} -> (HoppyP.IO QDirFilters)
filter arg'1 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (filter' arg'1')

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

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

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

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

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

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

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

relativeFilePath :: (QDirValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
relativeFilePath arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (relativeFilePath' arg'1' arg'2')

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

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

sorting :: (QDirValue this) => (this) {- ^ this -} -> (HoppyP.IO QDirSortFlags)
sorting arg'1 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (sorting' arg'1')

aRRAY :: (QDirValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
aRRAY arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (aRRAY' arg'1' arg'2')

eQ :: (QDirValue this, QDirValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQDirPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QDirValue this, QDirValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQDirPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQDirPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QDirConstPtr this) => QDirPtr this where
  toQDir :: this -> QDir

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

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

setFilter :: (QDirPtr this, IsQDirFilters arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFilter arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDir arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirFilters
  ) arg'2 >>= \arg'2' ->
  (setFilter' arg'1' arg'2')

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

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

refresh :: (QDirPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
refresh arg'1 =
  HoppyFHR.withCppPtr (toQDir arg'1) $ \arg'1' ->
  (refresh' arg'1')

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

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

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

setSorting :: (QDirPtr this, IsQDirSortFlags arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSorting arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDir arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQDirSortFlags
  ) arg'2 >>= \arg'2' ->
  (setSorting' arg'1' arg'2')

swap :: (QDirPtr this, QDirPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDir arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQDir arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QDirPtr this, QDirValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QDir)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDir arg'1) $ \arg'1' ->
  withQDirPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QDir
  (aSSIGN' arg'1' arg'2')

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

cleanPath :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
cleanPath arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (cleanPath' arg'1')

current :: (HoppyP.IO QDir)
current =
  (HoppyFHR.decodeAndDelete . QDirConst) =<<
  (current')

currentPath :: (HoppyP.IO QtahP.String)
currentPath =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (currentPath')

fromNativeSeparators :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
fromNativeSeparators arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (fromNativeSeparators' arg'1')

home :: (HoppyP.IO QDir)
home =
  (HoppyFHR.decodeAndDelete . QDirConst) =<<
  (home')

homePath :: (HoppyP.IO QtahP.String)
homePath =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (homePath')

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

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

match :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
match 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.return . (/= 0))
  ) =<<
  (match' arg'1' arg'2')

root :: (HoppyP.IO QDir)
root =
  (HoppyFHR.decodeAndDelete . QDirConst) =<<
  (root')

rootPath :: (HoppyP.IO QtahP.String)
rootPath =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (rootPath')

separator :: (HoppyP.IO QtahP.Char)
separator =
  (HoppyFHR.decodeAndDelete . M16.QCharConst) =<<
  (separator')

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

temp :: (HoppyP.IO QDir)
temp =
  (HoppyFHR.decodeAndDelete . QDirConst) =<<
  (temp')

tempPath :: (HoppyP.IO QtahP.String)
tempPath =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (tempPath')

toNativeSeparators :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
toNativeSeparators arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toNativeSeparators' arg'1')

data QDirConst =
    QDirConst (HoppyF.Ptr QDirConst)
  | QDirConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDirConst)
  deriving (HoppyP.Show)

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

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

castQDirToConst :: QDir -> QDirConst
castQDirToConst (QDir ptr') = QDirConst $ HoppyF.castPtr ptr'
castQDirToConst (QDirGc fptr' ptr') = QDirConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QDirConst QDir where copy = newCopy

instance QDirConstPtr QDirConst where
  toQDirConst = HoppyP.id

data QDir =
    QDir (HoppyF.Ptr QDir)
  | QDirGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDir)
  deriving (HoppyP.Show)

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

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

castQDirToNonconst :: QDirConst -> QDir
castQDirToNonconst (QDirConst ptr') = QDir $ HoppyF.castPtr ptr'
castQDirToNonconst (QDirConstGc fptr' ptr') = QDirGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QDir QDir where copy = newCopy

instance QDirConstPtr QDir where
  toQDirConst (QDir ptr') = QDirConst $ (HoppyF.castPtr :: HoppyF.Ptr QDir -> HoppyF.Ptr QDirConst) ptr'
  toQDirConst (QDirGc fptr' ptr') = QDirConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDir -> HoppyF.Ptr QDirConst) ptr'

instance QDirPtr QDir where
  toQDir = HoppyP.id

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

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

class QDirSuper a where
  downToQDir :: a -> QDir


class QDirSuperConst a where
  downToQDirConst :: a -> QDirConst


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

instance QDirValue a => HoppyFHR.Assignable QDir a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QDir (QDir) where
  decode = HoppyFHR.decode . toQDirConst

instance HoppyFHR.Decodable QDirConst (QDir) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QDirFilter =
  Dirs
  | AllDirs
  | Files
  | Drives
  | NoSymLinks
  | NoDotAndDotDot
  | NoDot
  | NoDotDot
  | AllEntries
  | Readable
  | Writable
  | Executable
  | Modified
  | Hidden
  | System
  | CaseSensitive
  | UnknownQDirFilter (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QDirFilter where
  fromCppEnum Dirs = 1
  fromCppEnum AllDirs = 1024
  fromCppEnum Files = 2
  fromCppEnum Drives = 4
  fromCppEnum NoSymLinks = 8
  fromCppEnum NoDotAndDotDot = 24576
  fromCppEnum NoDot = 8192
  fromCppEnum NoDotDot = 16384
  fromCppEnum AllEntries = 7
  fromCppEnum Readable = 16
  fromCppEnum Writable = 32
  fromCppEnum Executable = 64
  fromCppEnum Modified = 128
  fromCppEnum Hidden = 256
  fromCppEnum System = 512
  fromCppEnum CaseSensitive = 2048
  fromCppEnum (UnknownQDirFilter n) = n
  
  toCppEnum (1) = Dirs
  toCppEnum (2) = Files
  toCppEnum (4) = Drives
  toCppEnum (7) = AllEntries
  toCppEnum (8) = NoSymLinks
  toCppEnum (16) = Readable
  toCppEnum (32) = Writable
  toCppEnum (64) = Executable
  toCppEnum (128) = Modified
  toCppEnum (256) = Hidden
  toCppEnum (512) = System
  toCppEnum (1024) = AllDirs
  toCppEnum (2048) = CaseSensitive
  toCppEnum (8192) = NoDot
  toCppEnum (16384) = NoDotDot
  toCppEnum (24576) = NoDotAndDotDot
  toCppEnum n = UnknownQDirFilter n

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

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

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

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

class IsQDirFilters a where
  toQDirFilters :: a -> QDirFilters

instance IsQDirFilters QDirFilters where toQDirFilters = QtahP.id
instance IsQDirFilters QDirFilter where toQDirFilters = QtahFlags.enumToFlags
instance IsQDirFilters (HoppyFC.CInt) where toQDirFilters = QtahFlags.numToFlags

allDirs :: QDirFilters
allDirs = QDirFilters (1024)

allEntries :: QDirFilters
allEntries = QDirFilters (7)

caseSensitive :: QDirFilters
caseSensitive = QDirFilters (2048)

dirs :: QDirFilters
dirs = QDirFilters (1)

drives :: QDirFilters
drives = QDirFilters (4)

executable :: QDirFilters
executable = QDirFilters (64)

files :: QDirFilters
files = QDirFilters (2)

hidden :: QDirFilters
hidden = QDirFilters (256)

modified :: QDirFilters
modified = QDirFilters (128)

noDot :: QDirFilters
noDot = QDirFilters (8192)

noDotAndDotDot :: QDirFilters
noDotAndDotDot = QDirFilters (24576)

noDotDot :: QDirFilters
noDotDot = QDirFilters (16384)

noSymLinks :: QDirFilters
noSymLinks = QDirFilters (8)

readable :: QDirFilters
readable = QDirFilters (16)

system :: QDirFilters
system = QDirFilters (512)

writable :: QDirFilters
writable = QDirFilters (32)

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

data QDirSortFlag =
  Name
  | Time
  | Size
  | Typ
  | Unsorted
  | NoSort
  | DirsFirst
  | DirsLast
  | Reversed
  | IgnoreCase
  | LocaleAware
  | UnknownQDirSortFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QDirSortFlag where
  fromCppEnum Name = 0
  fromCppEnum Time = 1
  fromCppEnum Size = 2
  fromCppEnum Typ = 128
  fromCppEnum Unsorted = 3
  fromCppEnum NoSort = -1
  fromCppEnum DirsFirst = 4
  fromCppEnum DirsLast = 32
  fromCppEnum Reversed = 8
  fromCppEnum IgnoreCase = 16
  fromCppEnum LocaleAware = 64
  fromCppEnum (UnknownQDirSortFlag n) = n
  
  toCppEnum (-1) = NoSort
  toCppEnum (0) = Name
  toCppEnum (1) = Time
  toCppEnum (2) = Size
  toCppEnum (3) = Unsorted
  toCppEnum (4) = DirsFirst
  toCppEnum (8) = Reversed
  toCppEnum (16) = IgnoreCase
  toCppEnum (32) = DirsLast
  toCppEnum (64) = LocaleAware
  toCppEnum (128) = Typ
  toCppEnum n = UnknownQDirSortFlag n

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

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

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

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

class IsQDirSortFlags a where
  toQDirSortFlags :: a -> QDirSortFlags

instance IsQDirSortFlags QDirSortFlags where toQDirSortFlags = QtahP.id
instance IsQDirSortFlags QDirSortFlag where toQDirSortFlags = QtahFlags.enumToFlags
instance IsQDirSortFlags (HoppyFC.CInt) where toQDirSortFlags = QtahFlags.numToFlags

dirsFirst :: QDirSortFlags
dirsFirst = QDirSortFlags (4)

dirsLast :: QDirSortFlags
dirsLast = QDirSortFlags (32)

ignoreCase :: QDirSortFlags
ignoreCase = QDirSortFlags (16)

localeAware :: QDirSortFlags
localeAware = QDirSortFlags (64)

name :: QDirSortFlags
name = QDirSortFlags (0)

noSort :: QDirSortFlags
noSort = QDirSortFlags (-1)

reversed :: QDirSortFlags
reversed = QDirSortFlags (8)

size :: QDirSortFlags
size = QDirSortFlags (2)

time :: QDirSortFlags
time = QDirSortFlags (1)

typ :: QDirSortFlags
typ = QDirSortFlags (128)

unsorted :: QDirSortFlags
unsorted = QDirSortFlags (3)

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