namespace VULKAN_HPP_NAMESPACE
{
+${Flags}
+
template <typename EnumType, EnumType value>
struct CppType
{};
std::string str = replaceWithMap( vulkanEnumsHppTemplate,
{ { "enums", generateEnums() },
+ { "Flags", readSnippet( "Flags.hpp" ) },
{ "indexTypeTraits", generateIndexTypeTraits() },
{ "licenseHeader", m_vulkanLicenseHeader },
{ "objectTypeToDebugReportObjectType", generateObjectTypeToDebugReportObjectType() } } );
{
${ArrayWrapper1D}
${ArrayWrapper2D}
-${Flags}
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
${ArrayProxy}
${ArrayProxyNoTemporaries}
{ "DispatchLoaderStatic", generateDispatchLoaderStatic() },
{ "DynamicLoader", readSnippet( "DynamicLoader.hpp" ) },
{ "Exceptions", readSnippet( "Exceptions.hpp" ) },
- { "Flags", readSnippet( "Flags.hpp" ) },
{ "headerVersion", m_version },
{ "includes", replaceWithMap( readSnippet( "includes.hpp" ), { { "vulkan_h", ( m_api == "vulkan" ) ? "vulkan.h" : "vulkan_sc_core.h" } } ) },
{ "licenseHeader", m_vulkanLicenseHeader },
}
};
- template <typename FlagBitsType>
- struct FlagTraits
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
- };
-
- template <typename BitType>
- class Flags
- {
- public:
- using MaskType = typename std::underlying_type<BitType>::type;
-
- // constructors
- VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
-
- // relational operators
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( Flags<BitType> const & ) const = default;
-#else
- VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask < rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask <= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask > rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask >= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask == rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask != rhs.m_mask;
- }
-#endif
-
- // logical operator
- VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
- {
- return !m_mask;
- }
-
- // bitwise operators
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask & rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask | rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
- }
-
- // assignment operators
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask |= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask &= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask ^= rhs.m_mask;
- return *this;
- }
-
- // cast operators
- explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_mask;
- }
-
- explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
- {
- return m_mask;
- }
-
-#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
- public:
-#else
- private:
-#endif
- MaskType m_mask;
- };
-
-#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- // relational operators only needed for pre C++20
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator==( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator!=( bit );
- }
-#endif
-
- // bitwise operators
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator&( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator|( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator^( bit );
- }
-
- // bitwise operators on BitType
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) & rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) | rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) ^ rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
- {
- return ~( Flags<BitType>( bit ) );
- }
-
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
template <typename T>
class ArrayProxy
namespace VULKAN_HPP_NAMESPACE
{
+ template <typename FlagBitsType>
+ struct FlagTraits
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
+ };
+
+ template <typename BitType>
+ class Flags
+ {
+ public:
+ using MaskType = typename std::underlying_type<BitType>::type;
+
+ // constructors
+ VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
+
+ // relational operators
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( Flags<BitType> const & ) const = default;
+#else
+ VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask < rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask <= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask > rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask >= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask == rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask != rhs.m_mask;
+ }
+#endif
+
+ // logical operator
+ VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
+ {
+ return !m_mask;
+ }
+
+ // bitwise operators
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask & rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask | rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
+ }
+
+ // assignment operators
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask |= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask &= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask ^= rhs.m_mask;
+ return *this;
+ }
+
+ // cast operators
+ explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return !!m_mask;
+ }
+
+ explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask;
+ }
+
+#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
+ public:
+#else
+ private:
+#endif
+ MaskType m_mask;
+ };
+
+#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ // relational operators only needed for pre C++20
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator==( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator!=( bit );
+ }
+#endif
+
+ // bitwise operators
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator&( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator|( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator^( bit );
+ }
+
+ // bitwise operators on BitType
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) & rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) | rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) ^ rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
+ {
+ return ~( Flags<BitType>( bit ) );
+ }
+
template <typename EnumType, EnumType value>
struct CppType
{
}
};
- template <typename FlagBitsType>
- struct FlagTraits
- {
- static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
- };
-
- template <typename BitType>
- class Flags
- {
- public:
- using MaskType = typename std::underlying_type<BitType>::type;
-
- // constructors
- VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
-
- VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
-
- // relational operators
-#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- auto operator<=>( Flags<BitType> const & ) const = default;
-#else
- VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask < rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask <= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask > rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask >= rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask == rhs.m_mask;
- }
-
- VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask != rhs.m_mask;
- }
-#endif
-
- // logical operator
- VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
- {
- return !m_mask;
- }
-
- // bitwise operators
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask & rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask | rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ rhs.m_mask );
- }
-
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
- }
-
- // assignment operators
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask |= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask &= rhs.m_mask;
- return *this;
- }
-
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- m_mask ^= rhs.m_mask;
- return *this;
- }
-
- // cast operators
- explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_mask;
- }
-
- explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
- {
- return m_mask;
- }
-
-#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
- public:
-#else
- private:
-#endif
- MaskType m_mask;
- };
-
-#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
- // relational operators only needed for pre C++20
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator>=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator<=( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator==( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator!=( bit );
- }
-#endif
-
- // bitwise operators
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator&( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator|( bit );
- }
-
- template <typename BitType>
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
- {
- return flags.operator^( bit );
- }
-
- // bitwise operators on BitType
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) & rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) | rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>( lhs ) ^ rhs;
- }
-
- template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
- {
- return ~( Flags<BitType>( bit ) );
- }
-
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
template <typename T>
class ArrayProxy
namespace VULKAN_HPP_NAMESPACE
{
+ template <typename FlagBitsType>
+ struct FlagTraits
+ {
+ static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
+ };
+
+ template <typename BitType>
+ class Flags
+ {
+ public:
+ using MaskType = typename std::underlying_type<BitType>::type;
+
+ // constructors
+ VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
+
+ VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
+
+ // relational operators
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( Flags<BitType> const & ) const = default;
+#else
+ VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask < rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask <= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask > rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask >= rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask == rhs.m_mask;
+ }
+
+ VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask != rhs.m_mask;
+ }
+#endif
+
+ // logical operator
+ VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
+ {
+ return !m_mask;
+ }
+
+ // bitwise operators
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask & rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask | rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ rhs.m_mask );
+ }
+
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
+ }
+
+ // assignment operators
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask |= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask &= rhs.m_mask;
+ return *this;
+ }
+
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask ^= rhs.m_mask;
+ return *this;
+ }
+
+ // cast operators
+ explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return !!m_mask;
+ }
+
+ explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask;
+ }
+
+#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
+ public:
+#else
+ private:
+#endif
+ MaskType m_mask;
+ };
+
+#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ // relational operators only needed for pre C++20
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<=( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator==( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator!=( bit );
+ }
+#endif
+
+ // bitwise operators
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator&( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator|( bit );
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator^( bit );
+ }
+
+ // bitwise operators on BitType
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) & rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) | rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( lhs ) ^ rhs;
+ }
+
+ template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
+ {
+ return ~( Flags<BitType>( bit ) );
+ }
+
template <typename EnumType, EnumType value>
struct CppType
{