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

pattern ReadOnly :: AccessQualifier
pattern $bReadOnly :: AccessQualifier
$mReadOnly :: forall {r}. AccessQualifier -> ((# #) -> r) -> ((# #) -> r) -> r
ReadOnly = AccessQualifier 0

pattern WriteOnly :: AccessQualifier
pattern $bWriteOnly :: AccessQualifier
$mWriteOnly :: forall {r}. AccessQualifier -> ((# #) -> r) -> ((# #) -> r) -> r
WriteOnly = AccessQualifier 1

pattern ReadWrite :: AccessQualifier
pattern $bReadWrite :: AccessQualifier
$mReadWrite :: forall {r}. AccessQualifier -> ((# #) -> r) -> ((# #) -> r) -> r
ReadWrite = AccessQualifier 2

toName :: IsString a => AccessQualifier -> a
toName :: forall a. IsString a => AccessQualifier -> a
toName AccessQualifier
x = case AccessQualifier
x of
  AccessQualifier
ReadOnly -> a
"ReadOnly"
  AccessQualifier
WriteOnly -> a
"WriteOnly"
  AccessQualifier
ReadWrite -> a
"ReadWrite"
  AccessQualifier
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"AccessQualifier " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show AccessQualifier
unknown

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

fromName :: (IsString a, Eq a) => a -> Maybe AccessQualifier
fromName :: forall a. (IsString a, Eq a) => a -> Maybe AccessQualifier
fromName a
x = case a
x of
  a
"ReadOnly" -> forall a. a -> Maybe a
Just AccessQualifier
ReadOnly
  a
"WriteOnly" -> forall a. a -> Maybe a
Just AccessQualifier
WriteOnly
  a
"ReadWrite" -> forall a. a -> Maybe a
Just AccessQualifier
ReadWrite
  a
_unknown -> forall a. Maybe a
Nothing

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