{-# OPTIONS_HADDOCK ignore-exports#-}
{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures             #-}
{-# LANGUAGE PatternSynonyms            #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE Strict                     #-}
{-# LANGUAGE TypeSynonymInstances       #-}
module Graphics.Vulkan.Types.Enum.Command
       (VkCommandBufferLevel(VkCommandBufferLevel,
                             VK_COMMAND_BUFFER_LEVEL_PRIMARY,
                             VK_COMMAND_BUFFER_LEVEL_SECONDARY),
        VkCommandBufferResetBitmask(VkCommandBufferResetBitmask,
                                    VkCommandBufferResetFlags, VkCommandBufferResetFlagBits,
                                    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT),
        VkCommandBufferResetFlags, VkCommandBufferResetFlagBits,
        VkCommandBufferUsageBitmask(VkCommandBufferUsageBitmask,
                                    VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits,
                                    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
                                    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
                                    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT),
        VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits,
        VkCommandPoolCreateBitmask(VkCommandPoolCreateBitmask,
                                   VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits,
                                   VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
                                   VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT),
        VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits,
        VkCommandPoolResetBitmask(VkCommandPoolResetBitmask,
                                  VkCommandPoolResetFlags, VkCommandPoolResetFlagBits,
                                  VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT),
        VkCommandPoolResetFlags, VkCommandPoolResetFlagBits)
       where
import           Data.Bits                       (Bits, FiniteBits)
import           Data.Data                       (Data)
import           Foreign.Storable                (Storable)
import           GHC.Generics                    (Generic)
import           GHC.Read                        (choose, expectP)
import           Graphics.Vulkan.Marshal         (FlagBit, FlagMask, FlagType,
                                                  Int32)
import           Graphics.Vulkan.Types.BaseTypes (VkFlags (..))
import           Text.ParserCombinators.ReadPrec (prec, step, (+++))
import           Text.Read                       (Read (..), parens)
import           Text.Read.Lex                   (Lexeme (..))

-- | type = @enum@
--
--   <https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VkCommandBufferLevel VkCommandBufferLevel registry at www.khronos.org>
newtype VkCommandBufferLevel = VkCommandBufferLevel Int32
                                 deriving (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
(VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> Eq VkCommandBufferLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c/= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
== :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c== :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
Eq, Eq VkCommandBufferLevel
Eq VkCommandBufferLevel
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> Ord VkCommandBufferLevel
VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
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 :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$cmin :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
max :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$cmax :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
>= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c>= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
> :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c> :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
<= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c<= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
< :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c< :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
compare :: VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
$ccompare :: VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
$cp1Ord :: Eq VkCommandBufferLevel
Ord, Integer -> VkCommandBufferLevel
VkCommandBufferLevel -> VkCommandBufferLevel
VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
(VkCommandBufferLevel
 -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> VkCommandBufferLevel)
-> (Integer -> VkCommandBufferLevel)
-> Num VkCommandBufferLevel
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkCommandBufferLevel
$cfromInteger :: Integer -> VkCommandBufferLevel
signum :: VkCommandBufferLevel -> VkCommandBufferLevel
$csignum :: VkCommandBufferLevel -> VkCommandBufferLevel
abs :: VkCommandBufferLevel -> VkCommandBufferLevel
$cabs :: VkCommandBufferLevel -> VkCommandBufferLevel
negate :: VkCommandBufferLevel -> VkCommandBufferLevel
$cnegate :: VkCommandBufferLevel -> VkCommandBufferLevel
* :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$c* :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
- :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$c- :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
+ :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$c+ :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
Num, VkCommandBufferLevel
VkCommandBufferLevel
-> VkCommandBufferLevel -> Bounded VkCommandBufferLevel
forall a. a -> a -> Bounded a
maxBound :: VkCommandBufferLevel
$cmaxBound :: VkCommandBufferLevel
minBound :: VkCommandBufferLevel
$cminBound :: VkCommandBufferLevel
Bounded, Ptr b -> Int -> IO VkCommandBufferLevel
Ptr b -> Int -> VkCommandBufferLevel -> IO ()
Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
VkCommandBufferLevel -> Int
(VkCommandBufferLevel -> Int)
-> (VkCommandBufferLevel -> Int)
-> (Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel)
-> (Ptr VkCommandBufferLevel
    -> Int -> VkCommandBufferLevel -> IO ())
-> (forall b. Ptr b -> Int -> IO VkCommandBufferLevel)
-> (forall b. Ptr b -> Int -> VkCommandBufferLevel -> IO ())
-> (Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel)
-> (Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ())
-> Storable VkCommandBufferLevel
forall b. Ptr b -> Int -> IO VkCommandBufferLevel
forall b. Ptr b -> Int -> VkCommandBufferLevel -> 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 VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
$cpoke :: Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
peek :: Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
$cpeek :: Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
pokeByteOff :: Ptr b -> Int -> VkCommandBufferLevel -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkCommandBufferLevel -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkCommandBufferLevel
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkCommandBufferLevel
pokeElemOff :: Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
$cpokeElemOff :: Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
peekElemOff :: Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
$cpeekElemOff :: Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
alignment :: VkCommandBufferLevel -> Int
$calignment :: VkCommandBufferLevel -> Int
sizeOf :: VkCommandBufferLevel -> Int
$csizeOf :: VkCommandBufferLevel -> Int
Storable, Int -> VkCommandBufferLevel
VkCommandBufferLevel -> Int
VkCommandBufferLevel -> [VkCommandBufferLevel]
VkCommandBufferLevel -> VkCommandBufferLevel
VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
(VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> VkCommandBufferLevel)
-> (Int -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> Int)
-> (VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel
    -> VkCommandBufferLevel
    -> [VkCommandBufferLevel])
-> Enum VkCommandBufferLevel
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
$cenumFromThenTo :: VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
enumFromTo :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFromTo :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
enumFromThen :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFromThen :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
enumFrom :: VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFrom :: VkCommandBufferLevel -> [VkCommandBufferLevel]
fromEnum :: VkCommandBufferLevel -> Int
$cfromEnum :: VkCommandBufferLevel -> Int
toEnum :: Int -> VkCommandBufferLevel
$ctoEnum :: Int -> VkCommandBufferLevel
pred :: VkCommandBufferLevel -> VkCommandBufferLevel
$cpred :: VkCommandBufferLevel -> VkCommandBufferLevel
succ :: VkCommandBufferLevel -> VkCommandBufferLevel
$csucc :: VkCommandBufferLevel -> VkCommandBufferLevel
Enum, Typeable VkCommandBufferLevel
DataType
Constr
Typeable VkCommandBufferLevel
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkCommandBufferLevel
    -> c VkCommandBufferLevel)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VkCommandBufferLevel)
-> (VkCommandBufferLevel -> Constr)
-> (VkCommandBufferLevel -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VkCommandBufferLevel))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VkCommandBufferLevel))
-> ((forall b. Data b => b -> b)
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> VkCommandBufferLevel -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VkCommandBufferLevel -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferLevel -> m VkCommandBufferLevel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferLevel -> m VkCommandBufferLevel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferLevel -> m VkCommandBufferLevel)
-> Data VkCommandBufferLevel
VkCommandBufferLevel -> DataType
VkCommandBufferLevel -> Constr
(forall b. Data b => b -> b)
-> VkCommandBufferLevel -> VkCommandBufferLevel
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferLevel
-> c VkCommandBufferLevel
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkCommandBufferLevel
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> VkCommandBufferLevel -> u
forall u.
(forall d. Data d => d -> u) -> VkCommandBufferLevel -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkCommandBufferLevel
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferLevel
-> c VkCommandBufferLevel
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkCommandBufferLevel)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkCommandBufferLevel)
$cVkCommandBufferLevel :: Constr
$tVkCommandBufferLevel :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
gmapMp :: (forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
gmapM :: (forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferLevel -> m VkCommandBufferLevel
gmapQi :: Int -> (forall d. Data d => d -> u) -> VkCommandBufferLevel -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> VkCommandBufferLevel -> u
gmapQ :: (forall d. Data d => d -> u) -> VkCommandBufferLevel -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> VkCommandBufferLevel -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkCommandBufferLevel -> r
gmapT :: (forall b. Data b => b -> b)
-> VkCommandBufferLevel -> VkCommandBufferLevel
$cgmapT :: (forall b. Data b => b -> b)
-> VkCommandBufferLevel -> VkCommandBufferLevel
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkCommandBufferLevel)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkCommandBufferLevel)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VkCommandBufferLevel)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkCommandBufferLevel)
dataTypeOf :: VkCommandBufferLevel -> DataType
$cdataTypeOf :: VkCommandBufferLevel -> DataType
toConstr :: VkCommandBufferLevel -> Constr
$ctoConstr :: VkCommandBufferLevel -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkCommandBufferLevel
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkCommandBufferLevel
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferLevel
-> c VkCommandBufferLevel
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferLevel
-> c VkCommandBufferLevel
$cp1Data :: Typeable VkCommandBufferLevel
Data, (forall x. VkCommandBufferLevel -> Rep VkCommandBufferLevel x)
-> (forall x. Rep VkCommandBufferLevel x -> VkCommandBufferLevel)
-> Generic VkCommandBufferLevel
forall x. Rep VkCommandBufferLevel x -> VkCommandBufferLevel
forall x. VkCommandBufferLevel -> Rep VkCommandBufferLevel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VkCommandBufferLevel x -> VkCommandBufferLevel
$cfrom :: forall x. VkCommandBufferLevel -> Rep VkCommandBufferLevel x
Generic)

instance Show VkCommandBufferLevel where
        showsPrec :: Int -> VkCommandBufferLevel -> ShowS
showsPrec Int
_ VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_PRIMARY
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_LEVEL_PRIMARY"
        showsPrec Int
_ VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_SECONDARY
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_LEVEL_SECONDARY"
        showsPrec Int
p (VkCommandBufferLevel Int32
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkCommandBufferLevel " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int32 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Int32
x)

instance Read VkCommandBufferLevel where
        readPrec :: ReadPrec VkCommandBufferLevel
readPrec
          = ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec VkCommandBufferLevel)]
-> ReadPrec VkCommandBufferLevel
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_COMMAND_BUFFER_LEVEL_PRIMARY",
                   VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_PRIMARY),
                  (String
"VK_COMMAND_BUFFER_LEVEL_SECONDARY",
                   VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_SECONDARY)]
                 ReadPrec VkCommandBufferLevel
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferLevel") ReadPrec ()
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (Int32 -> VkCommandBufferLevel
VkCommandBufferLevel (Int32 -> VkCommandBufferLevel)
-> ReadPrec Int32 -> ReadPrec VkCommandBufferLevel
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec Int32 -> ReadPrec Int32
forall a. ReadPrec a -> ReadPrec a
step ReadPrec Int32
forall a. Read a => ReadPrec a
readPrec)))

pattern VK_COMMAND_BUFFER_LEVEL_PRIMARY :: VkCommandBufferLevel

pattern $bVK_COMMAND_BUFFER_LEVEL_PRIMARY :: VkCommandBufferLevel
$mVK_COMMAND_BUFFER_LEVEL_PRIMARY :: forall r. VkCommandBufferLevel -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel 0

pattern VK_COMMAND_BUFFER_LEVEL_SECONDARY :: VkCommandBufferLevel

pattern $bVK_COMMAND_BUFFER_LEVEL_SECONDARY :: VkCommandBufferLevel
$mVK_COMMAND_BUFFER_LEVEL_SECONDARY :: forall r. VkCommandBufferLevel -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel 1

newtype VkCommandBufferResetBitmask (a ::
                                       FlagType) = VkCommandBufferResetBitmask VkFlags
                                                     deriving (VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
(VkCommandBufferResetBitmask a
 -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> Eq (VkCommandBufferResetBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
/= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
== :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
Eq, Eq (VkCommandBufferResetBitmask a)
Eq (VkCommandBufferResetBitmask a)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Ordering)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a)
-> Ord (VkCommandBufferResetBitmask a)
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
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
forall (a :: FlagType). Eq (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
min :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
$cmin :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
max :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
$cmax :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
>= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
> :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
<= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
< :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
compare :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
$cp1Ord :: forall (a :: FlagType). Eq (VkCommandBufferResetBitmask a)
Ord, Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
VkCommandBufferResetBitmask a -> Int
(VkCommandBufferResetBitmask a -> Int)
-> (VkCommandBufferResetBitmask a -> Int)
-> (Ptr (VkCommandBufferResetBitmask a)
    -> Int -> IO (VkCommandBufferResetBitmask a))
-> (Ptr (VkCommandBufferResetBitmask a)
    -> Int -> VkCommandBufferResetBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandBufferResetBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ())
-> (Ptr (VkCommandBufferResetBitmask a)
    -> IO (VkCommandBufferResetBitmask a))
-> (Ptr (VkCommandBufferResetBitmask a)
    -> VkCommandBufferResetBitmask a -> IO ())
-> Storable (VkCommandBufferResetBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
forall b. Ptr b -> Int -> VkCommandBufferResetBitmask a -> 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
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
poke :: Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
peek :: Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
pokeByteOff :: Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
pokeElemOff :: Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
alignment :: VkCommandBufferResetBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
sizeOf :: VkCommandBufferResetBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
Storable, Typeable (VkCommandBufferResetBitmask a)
DataType
Constr
Typeable (VkCommandBufferResetBitmask a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkCommandBufferResetBitmask a
    -> c (VkCommandBufferResetBitmask a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (VkCommandBufferResetBitmask a))
-> (VkCommandBufferResetBitmask a -> Constr)
-> (VkCommandBufferResetBitmask a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (VkCommandBufferResetBitmask a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VkCommandBufferResetBitmask a)))
-> ((forall b. Data b => b -> b)
    -> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandBufferResetBitmask a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandBufferResetBitmask a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> VkCommandBufferResetBitmask a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkCommandBufferResetBitmask a
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferResetBitmask a
    -> m (VkCommandBufferResetBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferResetBitmask a
    -> m (VkCommandBufferResetBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferResetBitmask a
    -> m (VkCommandBufferResetBitmask a))
-> Data (VkCommandBufferResetBitmask a)
VkCommandBufferResetBitmask a -> DataType
VkCommandBufferResetBitmask a -> Constr
(forall b. Data b => b -> b)
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferResetBitmask a
-> c (VkCommandBufferResetBitmask a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferResetBitmask a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a
-> u
forall u.
(forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
Typeable a =>
VkCommandBufferResetBitmask a -> DataType
forall (a :: FlagType).
Typeable a =>
VkCommandBufferResetBitmask a -> Constr
forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a
-> u
forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a -> [u]
forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferResetBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferResetBitmask a
-> c (VkCommandBufferResetBitmask a)
forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferResetBitmask a))
forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferResetBitmask a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferResetBitmask a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferResetBitmask a
-> c (VkCommandBufferResetBitmask a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferResetBitmask a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferResetBitmask a))
$cVkCommandBufferResetBitmask :: Constr
$tVkCommandBufferResetBitmask :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
$cgmapMo :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
gmapMp :: (forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
$cgmapMp :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
gmapM :: (forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
$cgmapM :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferResetBitmask a
-> m (VkCommandBufferResetBitmask a)
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a
-> u
$cgmapQi :: forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a
-> u
gmapQ :: (forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a -> [u]
$cgmapQ :: forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkCommandBufferResetBitmask a -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
$cgmapQr :: forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
$cgmapQl :: forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferResetBitmask a
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
$cgmapT :: forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferResetBitmask a))
$cdataCast2 :: forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferResetBitmask a))
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferResetBitmask a))
$cdataCast1 :: forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferResetBitmask a))
dataTypeOf :: VkCommandBufferResetBitmask a -> DataType
$cdataTypeOf :: forall (a :: FlagType).
Typeable a =>
VkCommandBufferResetBitmask a -> DataType
toConstr :: VkCommandBufferResetBitmask a -> Constr
$ctoConstr :: forall (a :: FlagType).
Typeable a =>
VkCommandBufferResetBitmask a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferResetBitmask a)
$cgunfold :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferResetBitmask a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferResetBitmask a
-> c (VkCommandBufferResetBitmask a)
$cgfoldl :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferResetBitmask a
-> c (VkCommandBufferResetBitmask a)
$cp1Data :: forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandBufferResetBitmask a)
Data, (forall x.
 VkCommandBufferResetBitmask a
 -> Rep (VkCommandBufferResetBitmask a) x)
-> (forall x.
    Rep (VkCommandBufferResetBitmask a) x
    -> VkCommandBufferResetBitmask a)
-> Generic (VkCommandBufferResetBitmask a)
forall x.
Rep (VkCommandBufferResetBitmask a) x
-> VkCommandBufferResetBitmask a
forall x.
VkCommandBufferResetBitmask a
-> Rep (VkCommandBufferResetBitmask a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (a :: FlagType) x.
Rep (VkCommandBufferResetBitmask a) x
-> VkCommandBufferResetBitmask a
forall (a :: FlagType) x.
VkCommandBufferResetBitmask a
-> Rep (VkCommandBufferResetBitmask a) x
$cto :: forall (a :: FlagType) x.
Rep (VkCommandBufferResetBitmask a) x
-> VkCommandBufferResetBitmask a
$cfrom :: forall (a :: FlagType) x.
VkCommandBufferResetBitmask a
-> Rep (VkCommandBufferResetBitmask a) x
Generic)

type VkCommandBufferResetFlags =
     VkCommandBufferResetBitmask FlagMask

type VkCommandBufferResetFlagBits =
     VkCommandBufferResetBitmask FlagBit

pattern VkCommandBufferResetFlagBits ::
        VkFlags -> VkCommandBufferResetBitmask FlagBit

pattern $bVkCommandBufferResetFlagBits :: VkFlags -> VkCommandBufferResetBitmask FlagBit
$mVkCommandBufferResetFlagBits :: forall r.
VkCommandBufferResetBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferResetFlagBits n =
        VkCommandBufferResetBitmask n

pattern VkCommandBufferResetFlags ::
        VkFlags -> VkCommandBufferResetBitmask FlagMask

pattern $bVkCommandBufferResetFlags :: VkFlags -> VkCommandBufferResetBitmask FlagMask
$mVkCommandBufferResetFlags :: forall r.
VkCommandBufferResetBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferResetFlags n = VkCommandBufferResetBitmask n

deriving instance Bits (VkCommandBufferResetBitmask FlagMask)

deriving instance FiniteBits (VkCommandBufferResetBitmask FlagMask)

deriving instance Integral (VkCommandBufferResetBitmask FlagMask)

deriving instance Num (VkCommandBufferResetBitmask FlagMask)

deriving instance Bounded (VkCommandBufferResetBitmask FlagMask)

deriving instance Enum (VkCommandBufferResetBitmask FlagMask)

deriving instance Real (VkCommandBufferResetBitmask FlagMask)

instance Show (VkCommandBufferResetBitmask a) where
        showsPrec :: Int -> VkCommandBufferResetBitmask a -> ShowS
showsPrec Int
_ VkCommandBufferResetBitmask a
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"
        showsPrec Int
p (VkCommandBufferResetBitmask VkFlags
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkCommandBufferResetBitmask " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 VkFlags
x)

instance Read (VkCommandBufferResetBitmask a) where
        readPrec :: ReadPrec (VkCommandBufferResetBitmask a)
readPrec
          = ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec (VkCommandBufferResetBitmask a))]
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT",
                   VkCommandBufferResetBitmask a
-> ReadPrec (VkCommandBufferResetBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferResetBitmask a
forall (a :: FlagType). VkCommandBufferResetBitmask a
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)]
                 ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferResetBitmask") ReadPrec ()
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (VkFlags -> VkCommandBufferResetBitmask a
forall (a :: FlagType). VkFlags -> VkCommandBufferResetBitmask a
VkCommandBufferResetBitmask (VkFlags -> VkCommandBufferResetBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandBufferResetBitmask a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec VkFlags -> ReadPrec VkFlags
forall a. ReadPrec a -> ReadPrec a
step ReadPrec VkFlags
forall a. Read a => ReadPrec a
readPrec)))

-- | Release resources owned by the buffer
--
--   bitpos = @0@
pattern VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT ::
        VkCommandBufferResetBitmask a

pattern $bVK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT :: VkCommandBufferResetBitmask a
$mVK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT :: forall r (a :: FlagType).
VkCommandBufferResetBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT =
        VkCommandBufferResetBitmask 1

newtype VkCommandBufferUsageBitmask (a ::
                                       FlagType) = VkCommandBufferUsageBitmask VkFlags
                                                     deriving (VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
(VkCommandBufferUsageBitmask a
 -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> Eq (VkCommandBufferUsageBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
/= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
== :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
Eq, Eq (VkCommandBufferUsageBitmask a)
Eq (VkCommandBufferUsageBitmask a)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Ordering)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a)
-> Ord (VkCommandBufferUsageBitmask a)
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
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
forall (a :: FlagType). Eq (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
min :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
$cmin :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
max :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
$cmax :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
>= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
> :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
<= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
< :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
compare :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
$cp1Ord :: forall (a :: FlagType). Eq (VkCommandBufferUsageBitmask a)
Ord, Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
VkCommandBufferUsageBitmask a -> Int
(VkCommandBufferUsageBitmask a -> Int)
-> (VkCommandBufferUsageBitmask a -> Int)
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> Int -> IO (VkCommandBufferUsageBitmask a))
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> Int -> VkCommandBufferUsageBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ())
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> IO (VkCommandBufferUsageBitmask a))
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> VkCommandBufferUsageBitmask a -> IO ())
-> Storable (VkCommandBufferUsageBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
forall b. Ptr b -> Int -> VkCommandBufferUsageBitmask a -> 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
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
poke :: Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
peek :: Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
pokeByteOff :: Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
pokeElemOff :: Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
alignment :: VkCommandBufferUsageBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
sizeOf :: VkCommandBufferUsageBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
Storable, Typeable (VkCommandBufferUsageBitmask a)
DataType
Constr
Typeable (VkCommandBufferUsageBitmask a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkCommandBufferUsageBitmask a
    -> c (VkCommandBufferUsageBitmask a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (VkCommandBufferUsageBitmask a))
-> (VkCommandBufferUsageBitmask a -> Constr)
-> (VkCommandBufferUsageBitmask a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (VkCommandBufferUsageBitmask a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VkCommandBufferUsageBitmask a)))
-> ((forall b. Data b => b -> b)
    -> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandBufferUsageBitmask a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandBufferUsageBitmask a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> VkCommandBufferUsageBitmask a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkCommandBufferUsageBitmask a
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferUsageBitmask a
    -> m (VkCommandBufferUsageBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferUsageBitmask a
    -> m (VkCommandBufferUsageBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandBufferUsageBitmask a
    -> m (VkCommandBufferUsageBitmask a))
-> Data (VkCommandBufferUsageBitmask a)
VkCommandBufferUsageBitmask a -> DataType
VkCommandBufferUsageBitmask a -> Constr
(forall b. Data b => b -> b)
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferUsageBitmask a
-> c (VkCommandBufferUsageBitmask a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferUsageBitmask a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a
-> u
forall u.
(forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
Typeable a =>
VkCommandBufferUsageBitmask a -> DataType
forall (a :: FlagType).
Typeable a =>
VkCommandBufferUsageBitmask a -> Constr
forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a
-> u
forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a -> [u]
forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferUsageBitmask a
-> c (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferUsageBitmask a))
forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferUsageBitmask a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferUsageBitmask a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferUsageBitmask a
-> c (VkCommandBufferUsageBitmask a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferUsageBitmask a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferUsageBitmask a))
$cVkCommandBufferUsageBitmask :: Constr
$tVkCommandBufferUsageBitmask :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
$cgmapMo :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
gmapMp :: (forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
$cgmapMp :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
gmapM :: (forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
$cgmapM :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandBufferUsageBitmask a
-> m (VkCommandBufferUsageBitmask a)
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a
-> u
$cgmapQi :: forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a
-> u
gmapQ :: (forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a -> [u]
$cgmapQ :: forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkCommandBufferUsageBitmask a -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
$cgmapQr :: forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
$cgmapQl :: forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandBufferUsageBitmask a
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
$cgmapT :: forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferUsageBitmask a))
$cdataCast2 :: forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandBufferUsageBitmask a))
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferUsageBitmask a))
$cdataCast1 :: forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandBufferUsageBitmask a))
dataTypeOf :: VkCommandBufferUsageBitmask a -> DataType
$cdataTypeOf :: forall (a :: FlagType).
Typeable a =>
VkCommandBufferUsageBitmask a -> DataType
toConstr :: VkCommandBufferUsageBitmask a -> Constr
$ctoConstr :: forall (a :: FlagType).
Typeable a =>
VkCommandBufferUsageBitmask a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferUsageBitmask a)
$cgunfold :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandBufferUsageBitmask a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferUsageBitmask a
-> c (VkCommandBufferUsageBitmask a)
$cgfoldl :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandBufferUsageBitmask a
-> c (VkCommandBufferUsageBitmask a)
$cp1Data :: forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandBufferUsageBitmask a)
Data, (forall x.
 VkCommandBufferUsageBitmask a
 -> Rep (VkCommandBufferUsageBitmask a) x)
-> (forall x.
    Rep (VkCommandBufferUsageBitmask a) x
    -> VkCommandBufferUsageBitmask a)
-> Generic (VkCommandBufferUsageBitmask a)
forall x.
Rep (VkCommandBufferUsageBitmask a) x
-> VkCommandBufferUsageBitmask a
forall x.
VkCommandBufferUsageBitmask a
-> Rep (VkCommandBufferUsageBitmask a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (a :: FlagType) x.
Rep (VkCommandBufferUsageBitmask a) x
-> VkCommandBufferUsageBitmask a
forall (a :: FlagType) x.
VkCommandBufferUsageBitmask a
-> Rep (VkCommandBufferUsageBitmask a) x
$cto :: forall (a :: FlagType) x.
Rep (VkCommandBufferUsageBitmask a) x
-> VkCommandBufferUsageBitmask a
$cfrom :: forall (a :: FlagType) x.
VkCommandBufferUsageBitmask a
-> Rep (VkCommandBufferUsageBitmask a) x
Generic)

type VkCommandBufferUsageFlags =
     VkCommandBufferUsageBitmask FlagMask

type VkCommandBufferUsageFlagBits =
     VkCommandBufferUsageBitmask FlagBit

pattern VkCommandBufferUsageFlagBits ::
        VkFlags -> VkCommandBufferUsageBitmask FlagBit

pattern $bVkCommandBufferUsageFlagBits :: VkFlags -> VkCommandBufferUsageBitmask FlagBit
$mVkCommandBufferUsageFlagBits :: forall r.
VkCommandBufferUsageBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferUsageFlagBits n =
        VkCommandBufferUsageBitmask n

pattern VkCommandBufferUsageFlags ::
        VkFlags -> VkCommandBufferUsageBitmask FlagMask

pattern $bVkCommandBufferUsageFlags :: VkFlags -> VkCommandBufferUsageBitmask FlagMask
$mVkCommandBufferUsageFlags :: forall r.
VkCommandBufferUsageBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferUsageFlags n = VkCommandBufferUsageBitmask n

deriving instance Bits (VkCommandBufferUsageBitmask FlagMask)

deriving instance FiniteBits (VkCommandBufferUsageBitmask FlagMask)

deriving instance Integral (VkCommandBufferUsageBitmask FlagMask)

deriving instance Num (VkCommandBufferUsageBitmask FlagMask)

deriving instance Bounded (VkCommandBufferUsageBitmask FlagMask)

deriving instance Enum (VkCommandBufferUsageBitmask FlagMask)

deriving instance Real (VkCommandBufferUsageBitmask FlagMask)

instance Show (VkCommandBufferUsageBitmask a) where
        showsPrec :: Int -> VkCommandBufferUsageBitmask a -> ShowS
showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"
        showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"
        showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
          = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"
        showsPrec Int
p (VkCommandBufferUsageBitmask VkFlags
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkCommandBufferUsageBitmask " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 VkFlags
x)

instance Read (VkCommandBufferUsageBitmask a) where
        readPrec :: ReadPrec (VkCommandBufferUsageBitmask a)
readPrec
          = ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec (VkCommandBufferUsageBitmask a))]
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT",
                   VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT),
                  (String
"VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT",
                   VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT),
                  (String
"VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT",
                   VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)]
                 ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferUsageBitmask") ReadPrec ()
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (VkFlags -> VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkFlags -> VkCommandBufferUsageBitmask a
VkCommandBufferUsageBitmask (VkFlags -> VkCommandBufferUsageBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec VkFlags -> ReadPrec VkFlags
forall a. ReadPrec a -> ReadPrec a
step ReadPrec VkFlags
forall a. Read a => ReadPrec a
readPrec)))

-- | bitpos = @0@
pattern VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT :: VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT :: forall r (a :: FlagType).
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT =
        VkCommandBufferUsageBitmask 1

-- | bitpos = @1@
pattern VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT :: VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT :: forall r (a :: FlagType).
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT =
        VkCommandBufferUsageBitmask 2

-- | Command buffer may be submitted/executed more than once simultaneously
--
--   bitpos = @2@
pattern VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT :: VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT :: forall r (a :: FlagType).
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT =
        VkCommandBufferUsageBitmask 4

newtype VkCommandPoolCreateBitmask (a ::
                                      FlagType) = VkCommandPoolCreateBitmask VkFlags
                                                    deriving (VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
(VkCommandPoolCreateBitmask a
 -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> Eq (VkCommandPoolCreateBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
/= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
== :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
Eq, Eq (VkCommandPoolCreateBitmask a)
Eq (VkCommandPoolCreateBitmask a)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Ordering)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a)
-> Ord (VkCommandPoolCreateBitmask a)
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
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
forall (a :: FlagType). Eq (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
min :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
$cmin :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
max :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
$cmax :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
>= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
> :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
<= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
< :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
compare :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
$cp1Ord :: forall (a :: FlagType). Eq (VkCommandPoolCreateBitmask a)
Ord, Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
VkCommandPoolCreateBitmask a -> Int
(VkCommandPoolCreateBitmask a -> Int)
-> (VkCommandPoolCreateBitmask a -> Int)
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> Int -> IO (VkCommandPoolCreateBitmask a))
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> Int -> VkCommandPoolCreateBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ())
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> IO (VkCommandPoolCreateBitmask a))
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> VkCommandPoolCreateBitmask a -> IO ())
-> Storable (VkCommandPoolCreateBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
forall b. Ptr b -> Int -> VkCommandPoolCreateBitmask a -> 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
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
poke :: Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
peek :: Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
pokeByteOff :: Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
pokeElemOff :: Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
alignment :: VkCommandPoolCreateBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
sizeOf :: VkCommandPoolCreateBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
Storable, Typeable (VkCommandPoolCreateBitmask a)
DataType
Constr
Typeable (VkCommandPoolCreateBitmask a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkCommandPoolCreateBitmask a
    -> c (VkCommandPoolCreateBitmask a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (VkCommandPoolCreateBitmask a))
-> (VkCommandPoolCreateBitmask a -> Constr)
-> (VkCommandPoolCreateBitmask a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (VkCommandPoolCreateBitmask a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VkCommandPoolCreateBitmask a)))
-> ((forall b. Data b => b -> b)
    -> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandPoolCreateBitmask a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandPoolCreateBitmask a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> VkCommandPoolCreateBitmask a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkCommandPoolCreateBitmask a
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolCreateBitmask a
    -> m (VkCommandPoolCreateBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolCreateBitmask a
    -> m (VkCommandPoolCreateBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolCreateBitmask a
    -> m (VkCommandPoolCreateBitmask a))
-> Data (VkCommandPoolCreateBitmask a)
VkCommandPoolCreateBitmask a -> DataType
VkCommandPoolCreateBitmask a -> Constr
(forall b. Data b => b -> b)
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolCreateBitmask a
-> c (VkCommandPoolCreateBitmask a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolCreateBitmask a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> VkCommandPoolCreateBitmask a
-> u
forall u.
(forall d. Data d => d -> u) -> VkCommandPoolCreateBitmask a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
Typeable a =>
VkCommandPoolCreateBitmask a -> DataType
forall (a :: FlagType).
Typeable a =>
VkCommandPoolCreateBitmask a -> Constr
forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandPoolCreateBitmask a
-> u
forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u) -> VkCommandPoolCreateBitmask a -> [u]
forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolCreateBitmask a
-> c (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolCreateBitmask a))
forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolCreateBitmask a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolCreateBitmask a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolCreateBitmask a
-> c (VkCommandPoolCreateBitmask a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolCreateBitmask a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolCreateBitmask a))
$cVkCommandPoolCreateBitmask :: Constr
$tVkCommandPoolCreateBitmask :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
$cgmapMo :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
gmapMp :: (forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
$cgmapMp :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
gmapM :: (forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
$cgmapM :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolCreateBitmask a -> m (VkCommandPoolCreateBitmask a)
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> VkCommandPoolCreateBitmask a
-> u
$cgmapQi :: forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkCommandPoolCreateBitmask a
-> u
gmapQ :: (forall d. Data d => d -> u) -> VkCommandPoolCreateBitmask a -> [u]
$cgmapQ :: forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u) -> VkCommandPoolCreateBitmask a -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
$cgmapQr :: forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
$cgmapQl :: forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolCreateBitmask a
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
$cgmapT :: forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolCreateBitmask a))
$cdataCast2 :: forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolCreateBitmask a))
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolCreateBitmask a))
$cdataCast1 :: forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolCreateBitmask a))
dataTypeOf :: VkCommandPoolCreateBitmask a -> DataType
$cdataTypeOf :: forall (a :: FlagType).
Typeable a =>
VkCommandPoolCreateBitmask a -> DataType
toConstr :: VkCommandPoolCreateBitmask a -> Constr
$ctoConstr :: forall (a :: FlagType).
Typeable a =>
VkCommandPoolCreateBitmask a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolCreateBitmask a)
$cgunfold :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolCreateBitmask a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolCreateBitmask a
-> c (VkCommandPoolCreateBitmask a)
$cgfoldl :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolCreateBitmask a
-> c (VkCommandPoolCreateBitmask a)
$cp1Data :: forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandPoolCreateBitmask a)
Data, (forall x.
 VkCommandPoolCreateBitmask a
 -> Rep (VkCommandPoolCreateBitmask a) x)
-> (forall x.
    Rep (VkCommandPoolCreateBitmask a) x
    -> VkCommandPoolCreateBitmask a)
-> Generic (VkCommandPoolCreateBitmask a)
forall x.
Rep (VkCommandPoolCreateBitmask a) x
-> VkCommandPoolCreateBitmask a
forall x.
VkCommandPoolCreateBitmask a
-> Rep (VkCommandPoolCreateBitmask a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (a :: FlagType) x.
Rep (VkCommandPoolCreateBitmask a) x
-> VkCommandPoolCreateBitmask a
forall (a :: FlagType) x.
VkCommandPoolCreateBitmask a
-> Rep (VkCommandPoolCreateBitmask a) x
$cto :: forall (a :: FlagType) x.
Rep (VkCommandPoolCreateBitmask a) x
-> VkCommandPoolCreateBitmask a
$cfrom :: forall (a :: FlagType) x.
VkCommandPoolCreateBitmask a
-> Rep (VkCommandPoolCreateBitmask a) x
Generic)

type VkCommandPoolCreateFlags = VkCommandPoolCreateBitmask FlagMask

type VkCommandPoolCreateFlagBits =
     VkCommandPoolCreateBitmask FlagBit

pattern VkCommandPoolCreateFlagBits ::
        VkFlags -> VkCommandPoolCreateBitmask FlagBit

pattern $bVkCommandPoolCreateFlagBits :: VkFlags -> VkCommandPoolCreateBitmask FlagBit
$mVkCommandPoolCreateFlagBits :: forall r.
VkCommandPoolCreateBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolCreateFlagBits n =
        VkCommandPoolCreateBitmask n

pattern VkCommandPoolCreateFlags ::
        VkFlags -> VkCommandPoolCreateBitmask FlagMask

pattern $bVkCommandPoolCreateFlags :: VkFlags -> VkCommandPoolCreateBitmask FlagMask
$mVkCommandPoolCreateFlags :: forall r.
VkCommandPoolCreateBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolCreateFlags n = VkCommandPoolCreateBitmask n

deriving instance Bits (VkCommandPoolCreateBitmask FlagMask)

deriving instance FiniteBits (VkCommandPoolCreateBitmask FlagMask)

deriving instance Integral (VkCommandPoolCreateBitmask FlagMask)

deriving instance Num (VkCommandPoolCreateBitmask FlagMask)

deriving instance Bounded (VkCommandPoolCreateBitmask FlagMask)

deriving instance Enum (VkCommandPoolCreateBitmask FlagMask)

deriving instance Real (VkCommandPoolCreateBitmask FlagMask)

instance Show (VkCommandPoolCreateBitmask a) where
        showsPrec :: Int -> VkCommandPoolCreateBitmask a -> ShowS
showsPrec Int
_ VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
          = String -> ShowS
showString String
"VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"
        showsPrec Int
_ VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
          = String -> ShowS
showString String
"VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"
        showsPrec Int
p (VkCommandPoolCreateBitmask VkFlags
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkCommandPoolCreateBitmask " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 VkFlags
x)

instance Read (VkCommandPoolCreateBitmask a) where
        readPrec :: ReadPrec (VkCommandPoolCreateBitmask a)
readPrec
          = ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec (VkCommandPoolCreateBitmask a))]
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_COMMAND_POOL_CREATE_TRANSIENT_BIT",
                   VkCommandPoolCreateBitmask a
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT),
                  (String
"VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT",
                   VkCommandPoolCreateBitmask a
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)]
                 ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandPoolCreateBitmask") ReadPrec ()
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (VkFlags -> VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkFlags -> VkCommandPoolCreateBitmask a
VkCommandPoolCreateBitmask (VkFlags -> VkCommandPoolCreateBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandPoolCreateBitmask a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec VkFlags -> ReadPrec VkFlags
forall a. ReadPrec a -> ReadPrec a
step ReadPrec VkFlags
forall a. Read a => ReadPrec a
readPrec)))

-- | Command buffers have a short lifetime
--
--   bitpos = @0@
pattern VK_COMMAND_POOL_CREATE_TRANSIENT_BIT ::
        VkCommandPoolCreateBitmask a

pattern $bVK_COMMAND_POOL_CREATE_TRANSIENT_BIT :: VkCommandPoolCreateBitmask a
$mVK_COMMAND_POOL_CREATE_TRANSIENT_BIT :: forall r (a :: FlagType).
VkCommandPoolCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT =
        VkCommandPoolCreateBitmask 1

-- | Command buffers may release their memory individually
--
--   bitpos = @1@
pattern VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT ::
        VkCommandPoolCreateBitmask a

pattern $bVK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT :: VkCommandPoolCreateBitmask a
$mVK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT :: forall r (a :: FlagType).
VkCommandPoolCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT =
        VkCommandPoolCreateBitmask 2

newtype VkCommandPoolResetBitmask (a ::
                                     FlagType) = VkCommandPoolResetBitmask VkFlags
                                                   deriving (VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
(VkCommandPoolResetBitmask a
 -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> Eq (VkCommandPoolResetBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
/= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
== :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
Eq, Eq (VkCommandPoolResetBitmask a)
Eq (VkCommandPoolResetBitmask a)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Ordering)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a)
-> Ord (VkCommandPoolResetBitmask a)
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
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
forall (a :: FlagType). Eq (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
min :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
$cmin :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
max :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
$cmax :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
>= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
> :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
<= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
< :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
compare :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
$cp1Ord :: forall (a :: FlagType). Eq (VkCommandPoolResetBitmask a)
Ord, Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
VkCommandPoolResetBitmask a -> Int
(VkCommandPoolResetBitmask a -> Int)
-> (VkCommandPoolResetBitmask a -> Int)
-> (Ptr (VkCommandPoolResetBitmask a)
    -> Int -> IO (VkCommandPoolResetBitmask a))
-> (Ptr (VkCommandPoolResetBitmask a)
    -> Int -> VkCommandPoolResetBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandPoolResetBitmask a))
-> (forall b. Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ())
-> (Ptr (VkCommandPoolResetBitmask a)
    -> IO (VkCommandPoolResetBitmask a))
-> (Ptr (VkCommandPoolResetBitmask a)
    -> VkCommandPoolResetBitmask a -> IO ())
-> Storable (VkCommandPoolResetBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
forall b. Ptr b -> Int -> VkCommandPoolResetBitmask a -> 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
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
poke :: Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
peek :: Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
pokeByteOff :: Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
pokeElemOff :: Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
alignment :: VkCommandPoolResetBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
sizeOf :: VkCommandPoolResetBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
Storable, Typeable (VkCommandPoolResetBitmask a)
DataType
Constr
Typeable (VkCommandPoolResetBitmask a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkCommandPoolResetBitmask a
    -> c (VkCommandPoolResetBitmask a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (VkCommandPoolResetBitmask a))
-> (VkCommandPoolResetBitmask a -> Constr)
-> (VkCommandPoolResetBitmask a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (VkCommandPoolResetBitmask a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VkCommandPoolResetBitmask a)))
-> ((forall b. Data b => b -> b)
    -> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandPoolResetBitmask a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkCommandPoolResetBitmask a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkCommandPoolResetBitmask a
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a))
-> Data (VkCommandPoolResetBitmask a)
VkCommandPoolResetBitmask a -> DataType
VkCommandPoolResetBitmask a -> Constr
(forall b. Data b => b -> b)
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolResetBitmask a
-> c (VkCommandPoolResetBitmask a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolResetBitmask a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> u
forall u.
(forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
Typeable a =>
VkCommandPoolResetBitmask a -> DataType
forall (a :: FlagType).
Typeable a =>
VkCommandPoolResetBitmask a -> Constr
forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> u
forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> [u]
forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolResetBitmask a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolResetBitmask a
-> c (VkCommandPoolResetBitmask a)
forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolResetBitmask a))
forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolResetBitmask a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolResetBitmask a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolResetBitmask a
-> c (VkCommandPoolResetBitmask a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolResetBitmask a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolResetBitmask a))
$cVkCommandPoolResetBitmask :: Constr
$tVkCommandPoolResetBitmask :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
$cgmapMo :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
gmapMp :: (forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
$cgmapMp :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
gmapM :: (forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
$cgmapM :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkCommandPoolResetBitmask a -> m (VkCommandPoolResetBitmask a)
gmapQi :: Int
-> (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> u
$cgmapQi :: forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> u
gmapQ :: (forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> [u]
$cgmapQ :: forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u) -> VkCommandPoolResetBitmask a -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
$cgmapQr :: forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
$cgmapQl :: forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkCommandPoolResetBitmask a
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
$cgmapT :: forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolResetBitmask a))
$cdataCast2 :: forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkCommandPoolResetBitmask a))
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolResetBitmask a))
$cdataCast1 :: forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkCommandPoolResetBitmask a))
dataTypeOf :: VkCommandPoolResetBitmask a -> DataType
$cdataTypeOf :: forall (a :: FlagType).
Typeable a =>
VkCommandPoolResetBitmask a -> DataType
toConstr :: VkCommandPoolResetBitmask a -> Constr
$ctoConstr :: forall (a :: FlagType).
Typeable a =>
VkCommandPoolResetBitmask a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolResetBitmask a)
$cgunfold :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkCommandPoolResetBitmask a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolResetBitmask a
-> c (VkCommandPoolResetBitmask a)
$cgfoldl :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkCommandPoolResetBitmask a
-> c (VkCommandPoolResetBitmask a)
$cp1Data :: forall (a :: FlagType).
Typeable a =>
Typeable (VkCommandPoolResetBitmask a)
Data, (forall x.
 VkCommandPoolResetBitmask a -> Rep (VkCommandPoolResetBitmask a) x)
-> (forall x.
    Rep (VkCommandPoolResetBitmask a) x -> VkCommandPoolResetBitmask a)
-> Generic (VkCommandPoolResetBitmask a)
forall x.
Rep (VkCommandPoolResetBitmask a) x -> VkCommandPoolResetBitmask a
forall x.
VkCommandPoolResetBitmask a -> Rep (VkCommandPoolResetBitmask a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (a :: FlagType) x.
Rep (VkCommandPoolResetBitmask a) x -> VkCommandPoolResetBitmask a
forall (a :: FlagType) x.
VkCommandPoolResetBitmask a -> Rep (VkCommandPoolResetBitmask a) x
$cto :: forall (a :: FlagType) x.
Rep (VkCommandPoolResetBitmask a) x -> VkCommandPoolResetBitmask a
$cfrom :: forall (a :: FlagType) x.
VkCommandPoolResetBitmask a -> Rep (VkCommandPoolResetBitmask a) x
Generic)

type VkCommandPoolResetFlags = VkCommandPoolResetBitmask FlagMask

type VkCommandPoolResetFlagBits = VkCommandPoolResetBitmask FlagBit

pattern VkCommandPoolResetFlagBits ::
        VkFlags -> VkCommandPoolResetBitmask FlagBit

pattern $bVkCommandPoolResetFlagBits :: VkFlags -> VkCommandPoolResetBitmask FlagBit
$mVkCommandPoolResetFlagBits :: forall r.
VkCommandPoolResetBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolResetFlagBits n = VkCommandPoolResetBitmask n

pattern VkCommandPoolResetFlags ::
        VkFlags -> VkCommandPoolResetBitmask FlagMask

pattern $bVkCommandPoolResetFlags :: VkFlags -> VkCommandPoolResetBitmask FlagMask
$mVkCommandPoolResetFlags :: forall r.
VkCommandPoolResetBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolResetFlags n = VkCommandPoolResetBitmask n

deriving instance Bits (VkCommandPoolResetBitmask FlagMask)

deriving instance FiniteBits (VkCommandPoolResetBitmask FlagMask)

deriving instance Integral (VkCommandPoolResetBitmask FlagMask)

deriving instance Num (VkCommandPoolResetBitmask FlagMask)

deriving instance Bounded (VkCommandPoolResetBitmask FlagMask)

deriving instance Enum (VkCommandPoolResetBitmask FlagMask)

deriving instance Real (VkCommandPoolResetBitmask FlagMask)

instance Show (VkCommandPoolResetBitmask a) where
        showsPrec :: Int -> VkCommandPoolResetBitmask a -> ShowS
showsPrec Int
_ VkCommandPoolResetBitmask a
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
          = String -> ShowS
showString String
"VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"
        showsPrec Int
p (VkCommandPoolResetBitmask VkFlags
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkCommandPoolResetBitmask " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 VkFlags
x)

instance Read (VkCommandPoolResetBitmask a) where
        readPrec :: ReadPrec (VkCommandPoolResetBitmask a)
readPrec
          = ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec (VkCommandPoolResetBitmask a))]
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT",
                   VkCommandPoolResetBitmask a
-> ReadPrec (VkCommandPoolResetBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolResetBitmask a
forall (a :: FlagType). VkCommandPoolResetBitmask a
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)]
                 ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandPoolResetBitmask") ReadPrec ()
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (VkFlags -> VkCommandPoolResetBitmask a
forall (a :: FlagType). VkFlags -> VkCommandPoolResetBitmask a
VkCommandPoolResetBitmask (VkFlags -> VkCommandPoolResetBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandPoolResetBitmask a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec VkFlags -> ReadPrec VkFlags
forall a. ReadPrec a -> ReadPrec a
step ReadPrec VkFlags
forall a. Read a => ReadPrec a
readPrec)))

-- | Release resources owned by the pool
--
--   bitpos = @0@
pattern VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT ::
        VkCommandPoolResetBitmask a

pattern $bVK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT :: VkCommandPoolResetBitmask a
$mVK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT :: forall r (a :: FlagType).
VkCommandPoolResetBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT =
        VkCommandPoolResetBitmask 1