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

pattern Export :: LinkageType
pattern $bExport :: LinkageType
$mExport :: forall {r}. LinkageType -> ((# #) -> r) -> ((# #) -> r) -> r
Export = LinkageType 0

pattern Import :: LinkageType
pattern $bImport :: LinkageType
$mImport :: forall {r}. LinkageType -> ((# #) -> r) -> ((# #) -> r) -> r
Import = LinkageType 1

pattern LinkOnceODR :: LinkageType
pattern $bLinkOnceODR :: LinkageType
$mLinkOnceODR :: forall {r}. LinkageType -> ((# #) -> r) -> ((# #) -> r) -> r
LinkOnceODR = LinkageType 2

toName :: IsString a => LinkageType -> a
toName :: forall a. IsString a => LinkageType -> a
toName LinkageType
x = case LinkageType
x of
  LinkageType
Export -> a
"Export"
  LinkageType
Import -> a
"Import"
  LinkageType
LinkOnceODR -> a
"LinkOnceODR"
  LinkageType
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"LinkageType " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show LinkageType
unknown

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

fromName :: (IsString a, Eq a) => a -> Maybe LinkageType
fromName :: forall a. (IsString a, Eq a) => a -> Maybe LinkageType
fromName a
x = case a
x of
  a
"Export" -> forall a. a -> Maybe a
Just LinkageType
Export
  a
"Import" -> forall a. a -> Maybe a
Just LinkageType
Import
  a
"LinkOnceODR" -> forall a. a -> Maybe a
Just LinkageType
LinkOnceODR
  a
_unknown -> forall a. Maybe a
Nothing

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