module Data.SpirV.Enum.KernelEnqueueFlags where

import Data.String (IsString(..))
import Data.Word (Word32)
import Foreign (Storable(..))
import GHC.Read (Read(..))
import Text.ParserCombinators.ReadPrec (pfail)
import qualified GHC.Read as Read
import qualified Text.Read.Lex as Lex

newtype KernelEnqueueFlags = KernelEnqueueFlags Word32
  deriving (KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c/= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
== :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c== :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
Eq, Eq KernelEnqueueFlags
KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
KernelEnqueueFlags -> KernelEnqueueFlags -> Ordering
KernelEnqueueFlags -> KernelEnqueueFlags -> KernelEnqueueFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: KernelEnqueueFlags -> KernelEnqueueFlags -> KernelEnqueueFlags
$cmin :: KernelEnqueueFlags -> KernelEnqueueFlags -> KernelEnqueueFlags
max :: KernelEnqueueFlags -> KernelEnqueueFlags -> KernelEnqueueFlags
$cmax :: KernelEnqueueFlags -> KernelEnqueueFlags -> KernelEnqueueFlags
>= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c>= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
> :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c> :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
<= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c<= :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
< :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
$c< :: KernelEnqueueFlags -> KernelEnqueueFlags -> Bool
compare :: KernelEnqueueFlags -> KernelEnqueueFlags -> Ordering
$ccompare :: KernelEnqueueFlags -> KernelEnqueueFlags -> Ordering
Ord, Ptr KernelEnqueueFlags -> IO KernelEnqueueFlags
Ptr KernelEnqueueFlags -> Int -> IO KernelEnqueueFlags
Ptr KernelEnqueueFlags -> Int -> KernelEnqueueFlags -> IO ()
Ptr KernelEnqueueFlags -> KernelEnqueueFlags -> IO ()
KernelEnqueueFlags -> Int
forall b. Ptr b -> Int -> IO KernelEnqueueFlags
forall b. Ptr b -> Int -> KernelEnqueueFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr KernelEnqueueFlags -> KernelEnqueueFlags -> IO ()
$cpoke :: Ptr KernelEnqueueFlags -> KernelEnqueueFlags -> IO ()
peek :: Ptr KernelEnqueueFlags -> IO KernelEnqueueFlags
$cpeek :: Ptr KernelEnqueueFlags -> IO KernelEnqueueFlags
pokeByteOff :: forall b. Ptr b -> Int -> KernelEnqueueFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> KernelEnqueueFlags -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO KernelEnqueueFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO KernelEnqueueFlags
pokeElemOff :: Ptr KernelEnqueueFlags -> Int -> KernelEnqueueFlags -> IO ()
$cpokeElemOff :: Ptr KernelEnqueueFlags -> Int -> KernelEnqueueFlags -> IO ()
peekElemOff :: Ptr KernelEnqueueFlags -> Int -> IO KernelEnqueueFlags
$cpeekElemOff :: Ptr KernelEnqueueFlags -> Int -> IO KernelEnqueueFlags
alignment :: KernelEnqueueFlags -> Int
$calignment :: KernelEnqueueFlags -> Int
sizeOf :: KernelEnqueueFlags -> Int
$csizeOf :: KernelEnqueueFlags -> Int
Storable)

pattern NoWait :: KernelEnqueueFlags
pattern $bNoWait :: KernelEnqueueFlags
$mNoWait :: forall {r}. KernelEnqueueFlags -> ((# #) -> r) -> ((# #) -> r) -> r
NoWait = KernelEnqueueFlags 0

pattern WaitKernel :: KernelEnqueueFlags
pattern $bWaitKernel :: KernelEnqueueFlags
$mWaitKernel :: forall {r}. KernelEnqueueFlags -> ((# #) -> r) -> ((# #) -> r) -> r
WaitKernel = KernelEnqueueFlags 1

pattern WaitWorkGroup :: KernelEnqueueFlags
pattern $bWaitWorkGroup :: KernelEnqueueFlags
$mWaitWorkGroup :: forall {r}. KernelEnqueueFlags -> ((# #) -> r) -> ((# #) -> r) -> r
WaitWorkGroup = KernelEnqueueFlags 2

toName :: IsString a => KernelEnqueueFlags -> a
toName :: forall a. IsString a => KernelEnqueueFlags -> a
toName KernelEnqueueFlags
x = case KernelEnqueueFlags
x of
  KernelEnqueueFlags
NoWait -> a
"NoWait"
  KernelEnqueueFlags
WaitKernel -> a
"WaitKernel"
  KernelEnqueueFlags
WaitWorkGroup -> a
"WaitWorkGroup"
  KernelEnqueueFlags
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"KernelEnqueueFlags " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show KernelEnqueueFlags
unknown

instance Show KernelEnqueueFlags where
  show :: KernelEnqueueFlags -> [Char]
show = forall a. IsString a => KernelEnqueueFlags -> a
toName

fromName :: (IsString a, Eq a) => a -> Maybe KernelEnqueueFlags
fromName :: forall a. (IsString a, Eq a) => a -> Maybe KernelEnqueueFlags
fromName a
x = case a
x of
  a
"NoWait" -> forall a. a -> Maybe a
Just KernelEnqueueFlags
NoWait
  a
"WaitKernel" -> forall a. a -> Maybe a
Just KernelEnqueueFlags
WaitKernel
  a
"WaitWorkGroup" -> forall a. a -> Maybe a
Just KernelEnqueueFlags
WaitWorkGroup
  a
_unknown -> forall a. Maybe a
Nothing

instance Read KernelEnqueueFlags where
  readPrec :: ReadPrec KernelEnqueueFlags
readPrec = forall a. ReadPrec a -> ReadPrec a
Read.parens do
    Lex.Ident [Char]
s <- ReadPrec Lexeme
Read.lexP
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. ReadPrec a
pfail forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. (IsString a, Eq a) => a -> Maybe KernelEnqueueFlags
fromName [Char]
s