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

pattern R :: ImageChannelOrder
pattern $bR :: ImageChannelOrder
$mR :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
R = ImageChannelOrder 0

pattern A :: ImageChannelOrder
pattern $bA :: ImageChannelOrder
$mA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
A = ImageChannelOrder 1

pattern RG :: ImageChannelOrder
pattern $bRG :: ImageChannelOrder
$mRG :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RG = ImageChannelOrder 2

pattern RA :: ImageChannelOrder
pattern $bRA :: ImageChannelOrder
$mRA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RA = ImageChannelOrder 3

pattern RGB :: ImageChannelOrder
pattern $bRGB :: ImageChannelOrder
$mRGB :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RGB = ImageChannelOrder 4

pattern RGBA :: ImageChannelOrder
pattern $bRGBA :: ImageChannelOrder
$mRGBA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RGBA = ImageChannelOrder 5

pattern BGRA :: ImageChannelOrder
pattern $bBGRA :: ImageChannelOrder
$mBGRA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
BGRA = ImageChannelOrder 6

pattern ARGB :: ImageChannelOrder
pattern $bARGB :: ImageChannelOrder
$mARGB :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
ARGB = ImageChannelOrder 7

pattern Intensity :: ImageChannelOrder
pattern $bIntensity :: ImageChannelOrder
$mIntensity :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
Intensity = ImageChannelOrder 8

pattern Luminance :: ImageChannelOrder
pattern $bLuminance :: ImageChannelOrder
$mLuminance :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
Luminance = ImageChannelOrder 9

pattern Rx :: ImageChannelOrder
pattern $bRx :: ImageChannelOrder
$mRx :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
Rx = ImageChannelOrder 10

pattern RGx :: ImageChannelOrder
pattern $bRGx :: ImageChannelOrder
$mRGx :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RGx = ImageChannelOrder 11

pattern RGBx :: ImageChannelOrder
pattern $bRGBx :: ImageChannelOrder
$mRGBx :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
RGBx = ImageChannelOrder 12

pattern Depth :: ImageChannelOrder
pattern $bDepth :: ImageChannelOrder
$mDepth :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
Depth = ImageChannelOrder 13

pattern DepthStencil :: ImageChannelOrder
pattern $bDepthStencil :: ImageChannelOrder
$mDepthStencil :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
DepthStencil = ImageChannelOrder 14

pattern SRGB :: ImageChannelOrder
pattern $bSRGB :: ImageChannelOrder
$mSRGB :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
SRGB = ImageChannelOrder 15

pattern SRGBx :: ImageChannelOrder
pattern $bSRGBx :: ImageChannelOrder
$mSRGBx :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
SRGBx = ImageChannelOrder 16

pattern SRGBA :: ImageChannelOrder
pattern $bSRGBA :: ImageChannelOrder
$mSRGBA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
SRGBA = ImageChannelOrder 17

pattern SBGRA :: ImageChannelOrder
pattern $bSBGRA :: ImageChannelOrder
$mSBGRA :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
SBGRA = ImageChannelOrder 18

pattern ABGR :: ImageChannelOrder
pattern $bABGR :: ImageChannelOrder
$mABGR :: forall {r}. ImageChannelOrder -> ((# #) -> r) -> ((# #) -> r) -> r
ABGR = ImageChannelOrder 19

toName :: IsString a => ImageChannelOrder -> a
toName :: forall a. IsString a => ImageChannelOrder -> a
toName ImageChannelOrder
x = case ImageChannelOrder
x of
  ImageChannelOrder
R -> a
"R"
  ImageChannelOrder
A -> a
"A"
  ImageChannelOrder
RG -> a
"RG"
  ImageChannelOrder
RA -> a
"RA"
  ImageChannelOrder
RGB -> a
"RGB"
  ImageChannelOrder
RGBA -> a
"RGBA"
  ImageChannelOrder
BGRA -> a
"BGRA"
  ImageChannelOrder
ARGB -> a
"ARGB"
  ImageChannelOrder
Intensity -> a
"Intensity"
  ImageChannelOrder
Luminance -> a
"Luminance"
  ImageChannelOrder
Rx -> a
"Rx"
  ImageChannelOrder
RGx -> a
"RGx"
  ImageChannelOrder
RGBx -> a
"RGBx"
  ImageChannelOrder
Depth -> a
"Depth"
  ImageChannelOrder
DepthStencil -> a
"DepthStencil"
  ImageChannelOrder
SRGB -> a
"sRGB"
  ImageChannelOrder
SRGBx -> a
"sRGBx"
  ImageChannelOrder
SRGBA -> a
"sRGBA"
  ImageChannelOrder
SBGRA -> a
"sBGRA"
  ImageChannelOrder
ABGR -> a
"ABGR"
  ImageChannelOrder
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"ImageChannelOrder " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show ImageChannelOrder
unknown

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

fromName :: (IsString a, Eq a) => a -> Maybe ImageChannelOrder
fromName :: forall a. (IsString a, Eq a) => a -> Maybe ImageChannelOrder
fromName a
x = case a
x of
  a
"R" -> forall a. a -> Maybe a
Just ImageChannelOrder
R
  a
"A" -> forall a. a -> Maybe a
Just ImageChannelOrder
A
  a
"RG" -> forall a. a -> Maybe a
Just ImageChannelOrder
RG
  a
"RA" -> forall a. a -> Maybe a
Just ImageChannelOrder
RA
  a
"RGB" -> forall a. a -> Maybe a
Just ImageChannelOrder
RGB
  a
"RGBA" -> forall a. a -> Maybe a
Just ImageChannelOrder
RGBA
  a
"BGRA" -> forall a. a -> Maybe a
Just ImageChannelOrder
BGRA
  a
"ARGB" -> forall a. a -> Maybe a
Just ImageChannelOrder
ARGB
  a
"Intensity" -> forall a. a -> Maybe a
Just ImageChannelOrder
Intensity
  a
"Luminance" -> forall a. a -> Maybe a
Just ImageChannelOrder
Luminance
  a
"Rx" -> forall a. a -> Maybe a
Just ImageChannelOrder
Rx
  a
"RGx" -> forall a. a -> Maybe a
Just ImageChannelOrder
RGx
  a
"RGBx" -> forall a. a -> Maybe a
Just ImageChannelOrder
RGBx
  a
"Depth" -> forall a. a -> Maybe a
Just ImageChannelOrder
Depth
  a
"DepthStencil" -> forall a. a -> Maybe a
Just ImageChannelOrder
DepthStencil
  a
"sRGB" -> forall a. a -> Maybe a
Just ImageChannelOrder
SRGB
  a
"sRGBx" -> forall a. a -> Maybe a
Just ImageChannelOrder
SRGBx
  a
"sRGBA" -> forall a. a -> Maybe a
Just ImageChannelOrder
SRGBA
  a
"sBGRA" -> forall a. a -> Maybe a
Just ImageChannelOrder
SBGRA
  a
"ABGR" -> forall a. a -> Maybe a
Just ImageChannelOrder
ABGR
  a
_unknown -> forall a. Maybe a
Nothing

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