module Data.SpirV.Enum.StorageClass 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 StorageClass = StorageClass Word32
  deriving (StorageClass -> StorageClass -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StorageClass -> StorageClass -> Bool
$c/= :: StorageClass -> StorageClass -> Bool
== :: StorageClass -> StorageClass -> Bool
$c== :: StorageClass -> StorageClass -> Bool
Eq, Eq StorageClass
StorageClass -> StorageClass -> Bool
StorageClass -> StorageClass -> Ordering
StorageClass -> StorageClass -> StorageClass
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 :: StorageClass -> StorageClass -> StorageClass
$cmin :: StorageClass -> StorageClass -> StorageClass
max :: StorageClass -> StorageClass -> StorageClass
$cmax :: StorageClass -> StorageClass -> StorageClass
>= :: StorageClass -> StorageClass -> Bool
$c>= :: StorageClass -> StorageClass -> Bool
> :: StorageClass -> StorageClass -> Bool
$c> :: StorageClass -> StorageClass -> Bool
<= :: StorageClass -> StorageClass -> Bool
$c<= :: StorageClass -> StorageClass -> Bool
< :: StorageClass -> StorageClass -> Bool
$c< :: StorageClass -> StorageClass -> Bool
compare :: StorageClass -> StorageClass -> Ordering
$ccompare :: StorageClass -> StorageClass -> Ordering
Ord, Ptr StorageClass -> IO StorageClass
Ptr StorageClass -> Int -> IO StorageClass
Ptr StorageClass -> Int -> StorageClass -> IO ()
Ptr StorageClass -> StorageClass -> IO ()
StorageClass -> Int
forall b. Ptr b -> Int -> IO StorageClass
forall b. Ptr b -> Int -> StorageClass -> 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 StorageClass -> StorageClass -> IO ()
$cpoke :: Ptr StorageClass -> StorageClass -> IO ()
peek :: Ptr StorageClass -> IO StorageClass
$cpeek :: Ptr StorageClass -> IO StorageClass
pokeByteOff :: forall b. Ptr b -> Int -> StorageClass -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> StorageClass -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO StorageClass
$cpeekByteOff :: forall b. Ptr b -> Int -> IO StorageClass
pokeElemOff :: Ptr StorageClass -> Int -> StorageClass -> IO ()
$cpokeElemOff :: Ptr StorageClass -> Int -> StorageClass -> IO ()
peekElemOff :: Ptr StorageClass -> Int -> IO StorageClass
$cpeekElemOff :: Ptr StorageClass -> Int -> IO StorageClass
alignment :: StorageClass -> Int
$calignment :: StorageClass -> Int
sizeOf :: StorageClass -> Int
$csizeOf :: StorageClass -> Int
Storable)

pattern UniformConstant :: StorageClass
pattern $bUniformConstant :: StorageClass
$mUniformConstant :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
UniformConstant = StorageClass 0

pattern Input :: StorageClass
pattern $bInput :: StorageClass
$mInput :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Input = StorageClass 1

pattern Uniform :: StorageClass
pattern $bUniform :: StorageClass
$mUniform :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Uniform = StorageClass 2

pattern Output :: StorageClass
pattern $bOutput :: StorageClass
$mOutput :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Output = StorageClass 3

pattern Workgroup :: StorageClass
pattern $bWorkgroup :: StorageClass
$mWorkgroup :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Workgroup = StorageClass 4

pattern CrossWorkgroup :: StorageClass
pattern $bCrossWorkgroup :: StorageClass
$mCrossWorkgroup :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
CrossWorkgroup = StorageClass 5

pattern Private :: StorageClass
pattern $bPrivate :: StorageClass
$mPrivate :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Private = StorageClass 6

pattern Function :: StorageClass
pattern $bFunction :: StorageClass
$mFunction :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Function = StorageClass 7

pattern Generic :: StorageClass
pattern $bGeneric :: StorageClass
$mGeneric :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Generic = StorageClass 8

pattern PushConstant :: StorageClass
pattern $bPushConstant :: StorageClass
$mPushConstant :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
PushConstant = StorageClass 9

pattern AtomicCounter :: StorageClass
pattern $bAtomicCounter :: StorageClass
$mAtomicCounter :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
AtomicCounter = StorageClass 10

pattern Image :: StorageClass
pattern $bImage :: StorageClass
$mImage :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
Image = StorageClass 11

pattern StorageBuffer :: StorageClass
pattern $bStorageBuffer :: StorageClass
$mStorageBuffer :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
StorageBuffer = StorageClass 12

pattern CallableDataKHR :: StorageClass
pattern $bCallableDataKHR :: StorageClass
$mCallableDataKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
CallableDataKHR = StorageClass 5328

pattern CallableDataNV :: StorageClass
pattern $bCallableDataNV :: StorageClass
$mCallableDataNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
CallableDataNV = StorageClass 5328

pattern IncomingCallableDataKHR :: StorageClass
pattern $bIncomingCallableDataKHR :: StorageClass
$mIncomingCallableDataKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
IncomingCallableDataKHR = StorageClass 5329

pattern IncomingCallableDataNV :: StorageClass
pattern $bIncomingCallableDataNV :: StorageClass
$mIncomingCallableDataNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
IncomingCallableDataNV = StorageClass 5329

pattern RayPayloadKHR :: StorageClass
pattern $bRayPayloadKHR :: StorageClass
$mRayPayloadKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
RayPayloadKHR = StorageClass 5338

pattern RayPayloadNV :: StorageClass
pattern $bRayPayloadNV :: StorageClass
$mRayPayloadNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
RayPayloadNV = StorageClass 5338

pattern HitAttributeKHR :: StorageClass
pattern $bHitAttributeKHR :: StorageClass
$mHitAttributeKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
HitAttributeKHR = StorageClass 5339

pattern HitAttributeNV :: StorageClass
pattern $bHitAttributeNV :: StorageClass
$mHitAttributeNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
HitAttributeNV = StorageClass 5339

pattern IncomingRayPayloadKHR :: StorageClass
pattern $bIncomingRayPayloadKHR :: StorageClass
$mIncomingRayPayloadKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
IncomingRayPayloadKHR = StorageClass 5342

pattern IncomingRayPayloadNV :: StorageClass
pattern $bIncomingRayPayloadNV :: StorageClass
$mIncomingRayPayloadNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
IncomingRayPayloadNV = StorageClass 5342

pattern ShaderRecordBufferKHR :: StorageClass
pattern $bShaderRecordBufferKHR :: StorageClass
$mShaderRecordBufferKHR :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
ShaderRecordBufferKHR = StorageClass 5343

pattern ShaderRecordBufferNV :: StorageClass
pattern $bShaderRecordBufferNV :: StorageClass
$mShaderRecordBufferNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
ShaderRecordBufferNV = StorageClass 5343

pattern PhysicalStorageBuffer :: StorageClass
pattern $bPhysicalStorageBuffer :: StorageClass
$mPhysicalStorageBuffer :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
PhysicalStorageBuffer = StorageClass 5349

pattern PhysicalStorageBufferEXT :: StorageClass
pattern $bPhysicalStorageBufferEXT :: StorageClass
$mPhysicalStorageBufferEXT :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
PhysicalStorageBufferEXT = StorageClass 5349

pattern HitObjectAttributeNV :: StorageClass
pattern $bHitObjectAttributeNV :: StorageClass
$mHitObjectAttributeNV :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
HitObjectAttributeNV = StorageClass 5385

pattern TaskPayloadWorkgroupEXT :: StorageClass
pattern $bTaskPayloadWorkgroupEXT :: StorageClass
$mTaskPayloadWorkgroupEXT :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
TaskPayloadWorkgroupEXT = StorageClass 5402

pattern CodeSectionINTEL :: StorageClass
pattern $bCodeSectionINTEL :: StorageClass
$mCodeSectionINTEL :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
CodeSectionINTEL = StorageClass 5605

pattern DeviceOnlyINTEL :: StorageClass
pattern $bDeviceOnlyINTEL :: StorageClass
$mDeviceOnlyINTEL :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
DeviceOnlyINTEL = StorageClass 5936

pattern HostOnlyINTEL :: StorageClass
pattern $bHostOnlyINTEL :: StorageClass
$mHostOnlyINTEL :: forall {r}. StorageClass -> ((# #) -> r) -> ((# #) -> r) -> r
HostOnlyINTEL = StorageClass 5937

toName :: IsString a => StorageClass -> a
toName :: forall a. IsString a => StorageClass -> a
toName StorageClass
x = case StorageClass
x of
  StorageClass
UniformConstant -> a
"UniformConstant"
  StorageClass
Input -> a
"Input"
  StorageClass
Uniform -> a
"Uniform"
  StorageClass
Output -> a
"Output"
  StorageClass
Workgroup -> a
"Workgroup"
  StorageClass
CrossWorkgroup -> a
"CrossWorkgroup"
  StorageClass
Private -> a
"Private"
  StorageClass
Function -> a
"Function"
  StorageClass
Generic -> a
"Generic"
  StorageClass
PushConstant -> a
"PushConstant"
  StorageClass
AtomicCounter -> a
"AtomicCounter"
  StorageClass
Image -> a
"Image"
  StorageClass
StorageBuffer -> a
"StorageBuffer"
  StorageClass
CallableDataKHR -> a
"CallableDataKHR"
  StorageClass
CallableDataNV -> a
"CallableDataNV"
  StorageClass
IncomingCallableDataKHR -> a
"IncomingCallableDataKHR"
  StorageClass
IncomingCallableDataNV -> a
"IncomingCallableDataNV"
  StorageClass
RayPayloadKHR -> a
"RayPayloadKHR"
  StorageClass
RayPayloadNV -> a
"RayPayloadNV"
  StorageClass
HitAttributeKHR -> a
"HitAttributeKHR"
  StorageClass
HitAttributeNV -> a
"HitAttributeNV"
  StorageClass
IncomingRayPayloadKHR -> a
"IncomingRayPayloadKHR"
  StorageClass
IncomingRayPayloadNV -> a
"IncomingRayPayloadNV"
  StorageClass
ShaderRecordBufferKHR -> a
"ShaderRecordBufferKHR"
  StorageClass
ShaderRecordBufferNV -> a
"ShaderRecordBufferNV"
  StorageClass
PhysicalStorageBuffer -> a
"PhysicalStorageBuffer"
  StorageClass
PhysicalStorageBufferEXT -> a
"PhysicalStorageBufferEXT"
  StorageClass
HitObjectAttributeNV -> a
"HitObjectAttributeNV"
  StorageClass
TaskPayloadWorkgroupEXT -> a
"TaskPayloadWorkgroupEXT"
  StorageClass
CodeSectionINTEL -> a
"CodeSectionINTEL"
  StorageClass
DeviceOnlyINTEL -> a
"DeviceOnlyINTEL"
  StorageClass
HostOnlyINTEL -> a
"HostOnlyINTEL"
  StorageClass
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"StorageClass " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show StorageClass
unknown

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

fromName :: (IsString a, Eq a) => a -> Maybe StorageClass
fromName :: forall a. (IsString a, Eq a) => a -> Maybe StorageClass
fromName a
x = case a
x of
  a
"UniformConstant" -> forall a. a -> Maybe a
Just StorageClass
UniformConstant
  a
"Input" -> forall a. a -> Maybe a
Just StorageClass
Input
  a
"Uniform" -> forall a. a -> Maybe a
Just StorageClass
Uniform
  a
"Output" -> forall a. a -> Maybe a
Just StorageClass
Output
  a
"Workgroup" -> forall a. a -> Maybe a
Just StorageClass
Workgroup
  a
"CrossWorkgroup" -> forall a. a -> Maybe a
Just StorageClass
CrossWorkgroup
  a
"Private" -> forall a. a -> Maybe a
Just StorageClass
Private
  a
"Function" -> forall a. a -> Maybe a
Just StorageClass
Function
  a
"Generic" -> forall a. a -> Maybe a
Just StorageClass
Generic
  a
"PushConstant" -> forall a. a -> Maybe a
Just StorageClass
PushConstant
  a
"AtomicCounter" -> forall a. a -> Maybe a
Just StorageClass
AtomicCounter
  a
"Image" -> forall a. a -> Maybe a
Just StorageClass
Image
  a
"StorageBuffer" -> forall a. a -> Maybe a
Just StorageClass
StorageBuffer
  a
"CallableDataKHR" -> forall a. a -> Maybe a
Just StorageClass
CallableDataKHR
  a
"CallableDataNV" -> forall a. a -> Maybe a
Just StorageClass
CallableDataNV
  a
"IncomingCallableDataKHR" -> forall a. a -> Maybe a
Just StorageClass
IncomingCallableDataKHR
  a
"IncomingCallableDataNV" -> forall a. a -> Maybe a
Just StorageClass
IncomingCallableDataNV
  a
"RayPayloadKHR" -> forall a. a -> Maybe a
Just StorageClass
RayPayloadKHR
  a
"RayPayloadNV" -> forall a. a -> Maybe a
Just StorageClass
RayPayloadNV
  a
"HitAttributeKHR" -> forall a. a -> Maybe a
Just StorageClass
HitAttributeKHR
  a
"HitAttributeNV" -> forall a. a -> Maybe a
Just StorageClass
HitAttributeNV
  a
"IncomingRayPayloadKHR" -> forall a. a -> Maybe a
Just StorageClass
IncomingRayPayloadKHR
  a
"IncomingRayPayloadNV" -> forall a. a -> Maybe a
Just StorageClass
IncomingRayPayloadNV
  a
"ShaderRecordBufferKHR" -> forall a. a -> Maybe a
Just StorageClass
ShaderRecordBufferKHR
  a
"ShaderRecordBufferNV" -> forall a. a -> Maybe a
Just StorageClass
ShaderRecordBufferNV
  a
"PhysicalStorageBuffer" -> forall a. a -> Maybe a
Just StorageClass
PhysicalStorageBuffer
  a
"PhysicalStorageBufferEXT" -> forall a. a -> Maybe a
Just StorageClass
PhysicalStorageBufferEXT
  a
"HitObjectAttributeNV" -> forall a. a -> Maybe a
Just StorageClass
HitObjectAttributeNV
  a
"TaskPayloadWorkgroupEXT" -> forall a. a -> Maybe a
Just StorageClass
TaskPayloadWorkgroupEXT
  a
"CodeSectionINTEL" -> forall a. a -> Maybe a
Just StorageClass
CodeSectionINTEL
  a
"DeviceOnlyINTEL" -> forall a. a -> Maybe a
Just StorageClass
DeviceOnlyINTEL
  a
"HostOnlyINTEL" -> forall a. a -> Maybe a
Just StorageClass
HostOnlyINTEL
  a
_unknown -> forall a. Maybe a
Nothing

instance Read StorageClass where
  readPrec :: ReadPrec StorageClass
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 StorageClass
fromName [Char]
s