mewin/vulkan-hpp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added noexcept on all correct locations (RAII, internal classes, free functions, trivial cases) (#338)

Browse Source 
This includes complex cases such as generated functions (those not returning VkResult and nothing
with an allocator like std::vector), all internal classes (Flags),
all functions not returning VkResult, as well as all trivial cases.
This commit is contained in:
nyronium 2019-10-23 10:52:29 +02:00 committed by Markus Tavenrath
parent 65af859e4d
commit 6da60c59dc
2 changed files with 8369 additions and 8332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
VulkanHppGenerator.cpp
View File

@ -843,32 +843,32 @@ void VulkanHppGenerator::appendBitmask(std::string & str, std::string const& bit
}; };
}; };
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator|( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator|( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return ${bitmaskName}( bit0 ) | bit1; return ${bitmaskName}( bit0 ) | bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator&( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator&( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return ${bitmaskName}( bit0 ) & bit1; return ${bitmaskName}( bit0 ) & bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator^( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator^( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return ${bitmaskName}( bit0 ) ^ bit1; return ${bitmaskName}( bit0 ) ^ bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator~( ${enumName} bits ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ${bitmaskName} operator~( ${enumName} bits ) VULKAN_HPP_NOEXCEPT
{ {
return ~( ${bitmaskName}( bits ) ); return ~( ${bitmaskName}( bits ) );
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return ${bitmaskName}( bit0 ) == bit1; return ${bitmaskName}( bit0 ) == bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ${enumName} bit0, ${enumName} bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return ${bitmaskName}( bit0 ) != bit1; return ${bitmaskName}( bit0 ) != bit1;
} }
@ -1044,7 +1044,11 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
class DynamicLoader class DynamicLoader
{ {
public: public:
#ifdef VULKAN_HPP_NO_EXCEPTIONS
DynamicLoader() : m_success( false ) VULKAN_HPP_NOEXCEPT
#else
DynamicLoader() : m_success( false ) DynamicLoader() : m_success( false )
#endif
{ {
#if defined(__linux__) #if defined(__linux__)
m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
@ -1066,7 +1070,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
#endif #endif
} }
~DynamicLoader() ~DynamicLoader() VULKAN_HPP_NOEXCEPT
{ {
if ( m_library ) if ( m_library )
{ {
@ -1079,7 +1083,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
} }
template <typename T> template <typename T>
T getProcAddress( const char* function ) const T getProcAddress( const char* function ) const VULKAN_HPP_NOEXCEPT
{ {
#if defined(__linux__) || defined(__APPLE__) #if defined(__linux__) || defined(__APPLE__)
return (T)dlsym( m_library, function ); return (T)dlsym( m_library, function );
@ -1088,7 +1092,7 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
#endif #endif
} }
bool success() const { return m_success; } bool success() const VULKAN_HPP_NOEXCEPT { return m_success; }
private: private:
bool m_success; bool m_success;
@ -1167,28 +1171,28 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
// append initialization function to fetch function pointers // append initialization function to fetch function pointers
str += R"( str += R"(
public: public:
DispatchLoaderDynamic() = default; DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
#if !defined(VK_NO_PROTOTYPES) #if !defined(VK_NO_PROTOTYPES)
// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
DispatchLoaderDynamic(vk::Instance const& instance, vk::Device const& device) DispatchLoaderDynamic(vk::Instance const& instance, vk::Device const& device) VULKAN_HPP_NOEXCEPT
{ {
init(instance, device); init(instance, device);
} }
// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
void init(vk::Instance const& instance, vk::Device const& device) void init(vk::Instance const& instance, vk::Device const& device) VULKAN_HPP_NOEXCEPT
{ {
init(static_cast<VkInstance>(instance), ::vkGetInstanceProcAddr, static_cast<VkDevice>(device), device ? ::vkGetDeviceProcAddr : nullptr); init(static_cast<VkInstance>(instance), ::vkGetInstanceProcAddr, static_cast<VkDevice>(device), device ? ::vkGetDeviceProcAddr : nullptr);
} }
#endif // !defined(VK_NO_PROTOTYPES) #endif // !defined(VK_NO_PROTOTYPES)
DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
{ {
init(getInstanceProcAddr); init(getInstanceProcAddr);
} }
void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT(getInstanceProcAddr); VULKAN_HPP_ASSERT(getInstanceProcAddr);
@ -1200,13 +1204,13 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
str += R"( } str += R"( }
// This interface does not require a linked vulkan library. // This interface does not require a linked vulkan library.
DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
{ {
init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
} }
// This interface does not require a linked vulkan library. // This interface does not require a linked vulkan library.
void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT(instance && getInstanceProcAddr); VULKAN_HPP_ASSERT(instance && getInstanceProcAddr);
vkGetInstanceProcAddr = getInstanceProcAddr; vkGetInstanceProcAddr = getInstanceProcAddr;
@ -1216,14 +1220,14 @@ void VulkanHppGenerator::appendDispatchLoaderDynamic(std::string & str)
} }
} }
void init( vk::Instance instance ) void init( vk::Instance instance ) VULKAN_HPP_NOEXCEPT
{ {
)"; )";
str += strInstanceFunctions; str += strInstanceFunctions;
str += strDeviceFunctionsInstance; str += strDeviceFunctionsInstance;
str += " }\n\n"; str += " }\n\n";
str += " void init( vk::Device device )\n {\n"; str += " void init( vk::Device device ) VULKAN_HPP_NOEXCEPT\n {\n";
str += strDeviceFunctions; str += strDeviceFunctions;
str += R"( } str += R"( }
}; };
@ -1264,7 +1268,7 @@ void VulkanHppGenerator::appendDispatchLoaderStatic(std::string & str)
str += "\n"; str += "\n";
appendPlatformEnter(str, command.second.platform); appendPlatformEnter(str, command.second.platform);
str += " " + command.second.returnType + " vk" + commandName + "( " + parameterList + " ) const\n" str += " " + command.second.returnType + " vk" + commandName + "( " + parameterList + " ) const VULKAN_HPP_NOEXCEPT\n"
" {\n" " {\n"
" return ::vk" + commandName + "( " + parameters + " );\n" " return ::vk" + commandName + "( " + parameters + " );\n"
" }\n"; " }\n";
@ -1422,6 +1426,15 @@ void VulkanHppGenerator::appendFunction(std::string & str, std::string const& in
} }
appendFunctionHeaderArguments(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, enhanced, singular, !definition, withAllocator); appendFunctionHeaderArguments(str, commandData, returnParamIndex, templateParamIndex, vectorParamIndices, enhanced, singular, !definition, withAllocator);
// Any function that originally does not return VkResult can be marked noexcept,
// if it is enhanced it musnt't include anything with an Allocator
bool hasAllocator = enhancedReturnType.find("Allocator") != std::string::npos;
if (commandData.second.returnType != "VkResult" && (!enhanced || !hasAllocator))
{
str += " VULKAN_HPP_NOEXCEPT";
}
str += std::string(definition ? "" : ";") + "\n"; str += std::string(definition ? "" : ";") + "\n";
if (definition) if (definition)
@ -2255,58 +2268,58 @@ void VulkanHppGenerator::appendHandle(std::string & str, std::pair<std::string,
static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::e${className}; static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::e${className};
public: public:
VULKAN_HPP_CONSTEXPR ${className}() VULKAN_HPP_CONSTEXPR ${className}() VULKAN_HPP_NOEXCEPT
: m_${memberName}(VK_NULL_HANDLE) : m_${memberName}(VK_NULL_HANDLE)
{} {}
VULKAN_HPP_CONSTEXPR ${className}( std::nullptr_t ) VULKAN_HPP_CONSTEXPR ${className}( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
: m_${memberName}(VK_NULL_HANDLE) : m_${memberName}(VK_NULL_HANDLE)
{} {}
VULKAN_HPP_TYPESAFE_EXPLICIT ${className}( Vk${className} ${memberName} ) VULKAN_HPP_TYPESAFE_EXPLICIT ${className}( Vk${className} ${memberName} ) VULKAN_HPP_NOEXCEPT
: m_${memberName}( ${memberName} ) : m_${memberName}( ${memberName} )
{} {}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
${className} & operator=(Vk${className} ${memberName}) ${className} & operator=(Vk${className} ${memberName}) VULKAN_HPP_NOEXCEPT
{ {
m_${memberName} = ${memberName}; m_${memberName} = ${memberName};
return *this; return *this;
} }
#endif #endif
${className} & operator=( std::nullptr_t ) ${className} & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{ {
m_${memberName} = VK_NULL_HANDLE; m_${memberName} = VK_NULL_HANDLE;
return *this; return *this;
} }
bool operator==( ${className} const & rhs ) const bool operator==( ${className} const & rhs ) const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName} == rhs.m_${memberName}; return m_${memberName} == rhs.m_${memberName};
} }
bool operator!=(${className} const & rhs ) const bool operator!=(${className} const & rhs ) const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName} != rhs.m_${memberName}; return m_${memberName} != rhs.m_${memberName};
} }
bool operator<(${className} const & rhs ) const bool operator<(${className} const & rhs ) const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName} < rhs.m_${memberName}; return m_${memberName} < rhs.m_${memberName};
} }
${commands} ${commands}
VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk${className}() const VULKAN_HPP_TYPESAFE_EXPLICIT operator Vk${className}() const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName}; return m_${memberName};
} }
explicit operator bool() const explicit operator bool() const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName} != VK_NULL_HANDLE; return m_${memberName} != VK_NULL_HANDLE;
} }
bool operator!() const bool operator!() const VULKAN_HPP_NOEXCEPT
{ {
return m_${memberName} == VK_NULL_HANDLE; return m_${memberName} == VK_NULL_HANDLE;
} }
@ -2476,12 +2489,12 @@ void VulkanHppGenerator::appendStructCompareOperators(std::string & str, std::pa
} }
static const std::string compareTemplate = R"( static const std::string compareTemplate = R"(
bool operator==( ${name} const& rhs ) const bool operator==( ${name} const& rhs ) const VULKAN_HPP_NOEXCEPT
{ {
return ${compareMembers}; return ${compareMembers};
} }
bool operator!=( ${name} const& rhs ) const bool operator!=( ${name} const& rhs ) const VULKAN_HPP_NOEXCEPT
{ {
return !operator==( rhs ); return !operator==( rhs );
} }
@ -2541,7 +2554,7 @@ std::string VulkanHppGenerator::appendStructConstructor(std::pair<std::string, S
} }
} }
std::string structConstructor = ctorOpening + (arguments.empty() ? "()" : std::string("( " + arguments + " )")) + "\n"; std::string structConstructor = ctorOpening + (arguments.empty() ? "()" : std::string("( " + arguments + " )")) + " VULKAN_HPP_NOEXCEPT\n";
if (withLayoutStructure) if (withLayoutStructure)
{ {
structConstructor += prefix + " : layout::" + stripPrefix(structData.first, "Vk") + (initializers.empty() ? "()" : std::string("( " + initializers + " )")) + "\n" + prefix + "{}\n"; structConstructor += prefix + " : layout::" + stripPrefix(structData.first, "Vk") + (initializers.empty() ? "()" : std::string("( " + initializers + " )")) + "\n" + prefix + "{}\n";
@ -2618,23 +2631,23 @@ bool VulkanHppGenerator::appendStructConstructorArgument(std::string & str, bool
void VulkanHppGenerator::appendStructCopyConstructors(std::string & str, std::string const& name, bool withLayoutStructure) const void VulkanHppGenerator::appendStructCopyConstructors(std::string & str, std::string const& name, bool withLayoutStructure) const
{ {
static const std::string templateString = R"( static const std::string templateString = R"(
${name}( Vk${name} const & rhs ) ${name}( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
{ {
*reinterpret_cast<Vk${name}*>(this) = rhs; *reinterpret_cast<Vk${name}*>(this) = rhs;
} }
${name}& operator=( Vk${name} const & rhs ) ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
{ {
*reinterpret_cast<Vk${name}*>(this) = rhs; *reinterpret_cast<Vk${name}*>(this) = rhs;
return *this; return *this;
} }
)"; )";
static const std::string layoutTemplateString = R"( static const std::string layoutTemplateString = R"(
${name}( Vk${name} const & rhs ) ${name}( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
: layout::${name}( rhs ) : layout::${name}( rhs )
{} {}
${name}& operator=( Vk${name} const & rhs ) ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
{ {
layout::${name}::operator=(rhs); layout::${name}::operator=(rhs);
return *this; return *this;
@ -2690,7 +2703,7 @@ void VulkanHppGenerator::appendStructSetter(std::string & str, std::string const
// copy over the argument, either by assigning simple data, or by memcpy array data // copy over the argument, either by assigning simple data, or by memcpy array data
str += "\n" str += "\n"
" " + structureName + " & set" + startUpperCase(memberData.name) + "( " + memberType + " " + memberData.name + "_ )\n" " " + structureName + " & set" + startUpperCase(memberData.name) + "( " + memberType + " " + memberData.name + "_ ) VULKAN_HPP_NOEXCEPT\n"
" {\n" " {\n"
" "; " ";
if (memberData.arraySize.empty()) if (memberData.arraySize.empty())
@ -2725,12 +2738,12 @@ void VulkanHppGenerator::appendStructure(std::string & str, std::pair<std::strin
protected: protected:
${constructor} ${constructor}
${name}( Vk${name} const & rhs ) ${name}( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
{ {
*reinterpret_cast<Vk${name}*>(this) = rhs; *reinterpret_cast<Vk${name}*>(this) = rhs;
} }
${name}& operator=( Vk${name} const & rhs ) ${name}& operator=( Vk${name} const & rhs ) VULKAN_HPP_NOEXCEPT
{ {
*reinterpret_cast<Vk${name}*>(this) = rhs; *reinterpret_cast<Vk${name}*>(this) = rhs;
return *this; return *this;
@ -2790,12 +2803,12 @@ ${members} };
{ {
${constructorAndSetters} ${constructorAndSetters}
operator ${vkName} const&() const operator ${vkName} const&() const VULKAN_HPP_NOEXCEPT
{ {
return *reinterpret_cast<const ${vkName}*>( this ); return *reinterpret_cast<const ${vkName}*>( this );
} }
operator ${vkName} &() operator ${vkName} &() VULKAN_HPP_NOEXCEPT
{ {
return *reinterpret_cast<${vkName}*>( this ); return *reinterpret_cast<${vkName}*>( this );
} }
@ -4359,83 +4372,83 @@ int main( int argc, char **argv )
class ArrayProxy class ArrayProxy
{ {
public: public:
VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
: m_count(0) : m_count(0)
, m_ptr(nullptr) , m_ptr(nullptr)
{} {}
ArrayProxy(T & ptr) ArrayProxy(T & ptr) VULKAN_HPP_NOEXCEPT
: m_count(1) : m_count(1)
, m_ptr(&ptr) , m_ptr(&ptr)
{} {}
ArrayProxy(uint32_t count, T * ptr) ArrayProxy(uint32_t count, T * ptr) VULKAN_HPP_NOEXCEPT
: m_count(count) : m_count(count)
, m_ptr(ptr) , m_ptr(ptr)
{} {}
template <size_t N> template <size_t N>
ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data) ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data) VULKAN_HPP_NOEXCEPT
: m_count(N) : m_count(N)
, m_ptr(data.data()) , m_ptr(data.data())
{} {}
template <size_t N> template <size_t N>
ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data) ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data) VULKAN_HPP_NOEXCEPT
: m_count(N) : m_count(N)
, m_ptr(data.data()) , m_ptr(data.data())
{} {}
template <class Allocator = std::allocator<typename std::remove_const<T>::type>> template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data) ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data) VULKAN_HPP_NOEXCEPT
: m_count(static_cast<uint32_t>(data.size())) : m_count(static_cast<uint32_t>(data.size()))
, m_ptr(data.data()) , m_ptr(data.data())
{} {}
template <class Allocator = std::allocator<typename std::remove_const<T>::type>> template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data) ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data) VULKAN_HPP_NOEXCEPT
: m_count(static_cast<uint32_t>(data.size())) : m_count(static_cast<uint32_t>(data.size()))
, m_ptr(data.data()) , m_ptr(data.data())
{} {}
ArrayProxy(std::initializer_list<T> const& data) ArrayProxy(std::initializer_list<T> const& data) VULKAN_HPP_NOEXCEPT
: m_count(static_cast<uint32_t>(data.end() - data.begin())) : m_count(static_cast<uint32_t>(data.end() - data.begin()))
, m_ptr(data.begin()) , m_ptr(data.begin())
{} {}
const T * begin() const const T * begin() const VULKAN_HPP_NOEXCEPT
{ {
return m_ptr; return m_ptr;
} }
const T * end() const const T * end() const VULKAN_HPP_NOEXCEPT
{ {
return m_ptr + m_count; return m_ptr + m_count;
} }
const T & front() const const T & front() const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT(m_count && m_ptr); VULKAN_HPP_ASSERT(m_count && m_ptr);
return *m_ptr; return *m_ptr;
} }
const T & back() const const T & back() const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT(m_count && m_ptr); VULKAN_HPP_ASSERT(m_count && m_ptr);
return *(m_ptr + m_count - 1); return *(m_ptr + m_count - 1);
} }
bool empty() const bool empty() const VULKAN_HPP_NOEXCEPT
{ {
return (m_count == 0); return (m_count == 0);
} }
uint32_t size() const uint32_t size() const VULKAN_HPP_NOEXCEPT
{ {
return m_count; return m_count;
} }
T * data() const T * data() const VULKAN_HPP_NOEXCEPT
{ {
return m_ptr; return m_ptr;
} }
@ -4457,87 +4470,87 @@ int main( int argc, char **argv )
class Flags class Flags
{ {
public: public:
VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT
: m_mask(0) : m_mask(0)
{} {}
VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT
: m_mask(static_cast<MaskType>(bit)) : m_mask(static_cast<MaskType>(bit))
{} {}
VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const& rhs) VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
: m_mask(rhs.m_mask) : m_mask(rhs.m_mask)
{} {}
VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags) VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags) VULKAN_HPP_NOEXCEPT
: m_mask(flags) : m_mask(flags)
{} {}
Flags<BitType> & operator=(Flags<BitType> const& rhs) Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask = rhs.m_mask; m_mask = rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator|=(Flags<BitType> const& rhs) Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask |= rhs.m_mask; m_mask |= rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator&=(Flags<BitType> const& rhs) Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask &= rhs.m_mask; m_mask &= rhs.m_mask;
return *this; return *this;
} }
Flags<BitType> & operator^=(Flags<BitType> const& rhs) Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT
{ {
m_mask ^= rhs.m_mask; m_mask ^= rhs.m_mask;
return *this; return *this;
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const& rhs) const VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask | rhs.m_mask); return Flags<BitType>(m_mask | rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const& rhs) const VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask & rhs.m_mask); return Flags<BitType>(m_mask & rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const& rhs) const VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask ^ rhs.m_mask); return Flags<BitType>(m_mask ^ rhs.m_mask);
} }
VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
{ {
return !m_mask; return !m_mask;
} }
VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
{ {
return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags); return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags);
} }
VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const& rhs) const VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask == rhs.m_mask; return m_mask == rhs.m_mask;
} }
VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const& rhs) const VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const& rhs) const VULKAN_HPP_NOEXCEPT
{ {
return m_mask != rhs.m_mask; return m_mask != rhs.m_mask;
} }
explicit VULKAN_HPP_CONSTEXPR operator bool() const explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
{ {
return !!m_mask; return !!m_mask;
} }
explicit VULKAN_HPP_CONSTEXPR operator MaskType() const explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
{ {
return m_mask; return m_mask;
} }
@ -4547,31 +4560,31 @@ int main( int argc, char **argv )
}; };
template <typename BitType> template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags | bit; return flags | bit;
} }
template <typename BitType> template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags & bit; return flags & bit;
} }
template <typename BitType> template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags ^ bit; return flags ^ bit;
} }
template <typename BitType> template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags == bit; return flags == bit;
} }
template <typename BitType> template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const& flags) VULKAN_HPP_NOEXCEPT
{ {
return flags != bit; return flags != bit;
} }
@ -4584,18 +4597,18 @@ int main( int argc, char **argv )
class ObjectDestroy class ObjectDestroy
{ {
public: public:
ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
: m_owner( owner ) : m_owner( owner )
, m_allocationCallbacks( allocationCallbacks ) , m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch ) , m_dispatch( &dispatch )
{} {}
OwnerType getOwner() const { return m_owner; } OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; } Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
protected: protected:
template <typename T> template <typename T>
void destroy(T t) void destroy(T t) VULKAN_HPP_NOEXCEPT
{ {
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch ); m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
} }
@ -4612,16 +4625,16 @@ int main( int argc, char **argv )
class ObjectDestroy<NoParent,Dispatch> class ObjectDestroy<NoParent,Dispatch>
{ {
public: public:
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks ) : m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch ) , m_dispatch( &dispatch )
{} {}
Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; } Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
protected: protected:
template <typename T> template <typename T>
void destroy(T t) void destroy(T t) VULKAN_HPP_NOEXCEPT
{ {
t.destroy( m_allocationCallbacks, *m_dispatch ); t.destroy( m_allocationCallbacks, *m_dispatch );
} }
@ -4637,18 +4650,18 @@ int main( int argc, char **argv )
class ObjectFree class ObjectFree
{ {
public: public:
ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
: m_owner( owner ) : m_owner( owner )
, m_allocationCallbacks( allocationCallbacks ) , m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch ) , m_dispatch( &dispatch )
{} {}
OwnerType getOwner() const { return m_owner; } OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
Optional<const AllocationCallbacks> getAllocator() const { return m_allocationCallbacks; } Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
protected: protected:
template <typename T> template <typename T>
void destroy(T t) void destroy(T t) VULKAN_HPP_NOEXCEPT
{ {
m_owner.free( t, m_allocationCallbacks, *m_dispatch ); m_owner.free( t, m_allocationCallbacks, *m_dispatch );
} }
@ -4665,13 +4678,13 @@ int main( int argc, char **argv )
class Optional class Optional
{ {
public: public:
Optional(RefType & reference) { m_ptr = &reference; } Optional(RefType & reference) VULKAN_HPP_NOEXCEPT { m_ptr = &reference; }
Optional(RefType * ptr) { m_ptr = ptr; } Optional(RefType * ptr) VULKAN_HPP_NOEXCEPT { m_ptr = ptr; }
Optional(std::nullptr_t) { m_ptr = nullptr; } Optional(std::nullptr_t) VULKAN_HPP_NOEXCEPT { m_ptr = nullptr; }
operator RefType*() const { return m_ptr; } operator RefType*() const VULKAN_HPP_NOEXCEPT { return m_ptr; }
RefType const* operator->() const { return m_ptr; } RefType const* operator->() const VULKAN_HPP_NOEXCEPT { return m_ptr; }
explicit operator bool() const { return !!m_ptr; } explicit operator bool() const VULKAN_HPP_NOEXCEPT { return !!m_ptr; }
private: private:
RefType *m_ptr; RefType *m_ptr;
@ -4683,18 +4696,18 @@ int main( int argc, char **argv )
class PoolFree class PoolFree
{ {
public: public:
PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
: m_owner( owner ) : m_owner( owner )
, m_pool( pool ) , m_pool( pool )
, m_dispatch( &dispatch ) , m_dispatch( &dispatch )
{} {}
OwnerType getOwner() const { return m_owner; } OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
PoolType getPool() const { return m_pool; } PoolType getPool() const VULKAN_HPP_NOEXCEPT { return m_pool; }
protected: protected:
template <typename T> template <typename T>
void destroy(T t) void destroy(T t) VULKAN_HPP_NOEXCEPT
{ {
m_owner.free( m_pool, t, *m_dispatch ); m_owner.free( m_pool, t, *m_dispatch );
} }
@ -4738,8 +4751,8 @@ int main( int argc, char **argv )
class StructureChainElement class StructureChainElement
{ {
public: public:
explicit operator Element&() { return value; } explicit operator Element&() VULKAN_HPP_NOEXCEPT { return value; }
explicit operator const Element&() const { return value; } explicit operator const Element&() const VULKAN_HPP_NOEXCEPT { return value; }
private: private:
Element value; Element value;
}; };
@ -4748,28 +4761,28 @@ int main( int argc, char **argv )
class StructureChain : private StructureChainElement<StructureElements>... class StructureChain : private StructureChainElement<StructureElements>...
{ {
public: public:
StructureChain() StructureChain() VULKAN_HPP_NOEXCEPT
{ {
link<void, StructureElements...>(); link<void, StructureElements...>();
} }
StructureChain(StructureChain const &rhs) StructureChain(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
{ {
linkAndCopy<void, StructureElements...>(rhs); linkAndCopy<void, StructureElements...>(rhs);
} }
StructureChain(StructureElements const &... elems) StructureChain(StructureElements const &... elems) VULKAN_HPP_NOEXCEPT
{ {
linkAndCopyElements<void, StructureElements...>(elems...); linkAndCopyElements<void, StructureElements...>(elems...);
} }
StructureChain& operator=(StructureChain const &rhs) StructureChain& operator=(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
{ {
linkAndCopy<void, StructureElements...>(rhs); linkAndCopy<void, StructureElements...>(rhs);
return *this; return *this;
} }
template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);} template<typename ClassType> ClassType& get() VULKAN_HPP_NOEXCEPT { return static_cast<ClassType&>(*this);}
template<typename ClassTypeA, typename ClassTypeB, typename ...ClassTypes> template<typename ClassTypeA, typename ClassTypeB, typename ...ClassTypes>
std::tuple<ClassTypeA, ClassTypeB, ClassTypes...> get() std::tuple<ClassTypeA, ClassTypeB, ClassTypes...> get()
@ -4782,13 +4795,13 @@ int main( int argc, char **argv )
private: private:
template<typename List, typename X> template<typename List, typename X>
void link() void link() VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
} }
template<typename List, typename X, typename Y, typename ...Z> template<typename List, typename X, typename Y, typename ...Z>
void link() void link() VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List,X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List,X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this); X& x = static_cast<X&>(*this);
@ -4798,14 +4811,14 @@ int main( int argc, char **argv )
} }
template<typename List, typename X> template<typename List, typename X>
void linkAndCopy(StructureChain const &rhs) void linkAndCopy(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
static_cast<X&>(*this) = static_cast<X const &>(rhs); static_cast<X&>(*this) = static_cast<X const &>(rhs);
} }
template<typename List, typename X, typename Y, typename ...Z> template<typename List, typename X, typename Y, typename ...Z>
void linkAndCopy(StructureChain const &rhs) void linkAndCopy(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this); X& x = static_cast<X&>(*this);
@ -4816,14 +4829,14 @@ int main( int argc, char **argv )
} }
template<typename List, typename X> template<typename List, typename X>
void linkAndCopyElements(X const &xelem) void linkAndCopyElements(X const &xelem) VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
static_cast<X&>(*this) = xelem; static_cast<X&>(*this) = xelem;
} }
template<typename List, typename X, typename Y, typename ...Z> template<typename List, typename X, typename Y, typename ...Z>
void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem) void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem) VULKAN_HPP_NOEXCEPT
{ {
static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!"); static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
X& x = static_cast<X&>(*this); X& x = static_cast<X&>(*this);
@ -4848,68 +4861,68 @@ int main( int argc, char **argv )
public: public:
using element_type = Type; using element_type = Type;
explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() ) explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
: Deleter( deleter) : Deleter( deleter)
, m_value( value ) , m_value( value )
{} {}
UniqueHandle( UniqueHandle const& ) = delete; UniqueHandle( UniqueHandle const& ) = delete;
UniqueHandle( UniqueHandle && other ) UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
: Deleter( std::move( static_cast<Deleter&>( other ) ) ) : Deleter( std::move( static_cast<Deleter&>( other ) ) )
, m_value( other.release() ) , m_value( other.release() )
{} {}
~UniqueHandle() ~UniqueHandle() VULKAN_HPP_NOEXCEPT
{ {
if ( m_value ) this->destroy( m_value ); if ( m_value ) this->destroy( m_value );
} }
UniqueHandle & operator=( UniqueHandle const& ) = delete; UniqueHandle & operator=( UniqueHandle const& ) = delete;
UniqueHandle & operator=( UniqueHandle && other ) UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
{ {
reset( other.release() ); reset( other.release() );
*static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) ); *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
return *this; return *this;
} }
explicit operator bool() const explicit operator bool() const VULKAN_HPP_NOEXCEPT
{ {
return m_value.operator bool(); return m_value.operator bool();
} }
Type const* operator->() const Type const* operator->() const VULKAN_HPP_NOEXCEPT
{ {
return &m_value; return &m_value;
} }
Type * operator->() Type * operator->() VULKAN_HPP_NOEXCEPT
{ {
return &m_value; return &m_value;
} }
Type const& operator*() const Type const& operator*() const VULKAN_HPP_NOEXCEPT
{ {
return m_value; return m_value;
} }
Type & operator*() Type & operator*() VULKAN_HPP_NOEXCEPT
{ {
return m_value; return m_value;
} }
const Type & get() const const Type & get() const VULKAN_HPP_NOEXCEPT
{ {
return m_value; return m_value;
} }
Type & get() Type & get() VULKAN_HPP_NOEXCEPT
{ {
return m_value; return m_value;
} }
void reset( Type const& value = Type() ) void reset( Type const& value = Type() ) VULKAN_HPP_NOEXCEPT
{ {
if ( m_value != value ) if ( m_value != value )
{ {
@ -4918,14 +4931,14 @@ int main( int argc, char **argv )
} }
} }
Type release() Type release() VULKAN_HPP_NOEXCEPT
{ {
Type value = m_value; Type value = m_value;
m_value = nullptr; m_value = nullptr;
return value; return value;
} }
void swap( UniqueHandle<Type,Dispatch> & rhs ) void swap( UniqueHandle<Type,Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
{ {
std::swap(m_value, rhs.m_value); std::swap(m_value, rhs.m_value);
std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs)); std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
@ -4944,7 +4957,7 @@ int main( int argc, char **argv )
} }
template <typename Type, typename Dispatch> template <typename Type, typename Dispatch>
VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs ) VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Dispatch> & lhs, UniqueHandle<Type,Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
{ {
lhs.swap( rhs ); lhs.swap( rhs );
} }
@ -4956,7 +4969,7 @@ static const std::string constExpressionArrayCopy = R"(
class ConstExpressionArrayCopy class ConstExpressionArrayCopy
{ {
public: public:
VULKAN_HPP_CONSTEXPR_14 static void copy(T dst[N], std::array<T,N> const& src) VULKAN_HPP_CONSTEXPR_14 static void copy(T dst[N], std::array<T,N> const& src) VULKAN_HPP_NOEXCEPT
{ {
dst[I-1] = src[I-1]; dst[I-1] = src[I-1];
ConstExpressionArrayCopy<T, N, I - 1>::copy(dst, src); ConstExpressionArrayCopy<T, N, I - 1>::copy(dst, src);
@ -4967,7 +4980,7 @@ static const std::string constExpressionArrayCopy = R"(
class ConstExpressionArrayCopy<T, N, 0> class ConstExpressionArrayCopy<T, N, 0>
{ {
public: public:
VULKAN_HPP_CONSTEXPR_14 static void copy(T /*dst*/[N], std::array<T,N> const& /*src*/) {} VULKAN_HPP_CONSTEXPR_14 static void copy(T /*dst*/[N], std::array<T,N> const& /*src*/) VULKAN_HPP_NOEXCEPT {}
}; };
)"; )";
@ -5041,6 +5054,15 @@ static const std::string constExpressionArrayCopy = R"(
# define VULKAN_HPP_CONST_OR_CONSTEXPR const # define VULKAN_HPP_CONST_OR_CONSTEXPR const
#endif #endif
#if !defined(VULKAN_HPP_NOEXCEPT)
# if defined(_MSC_VER) && (_MSC_VER <= 1800)
# define VULKAN_HPP_NOEXCEPT
# else
# define VULKAN_HPP_NOEXCEPT noexcept
# define VULKAN_HPP_HAS_NOEXCEPT 1
# endif
#endif
#if !defined(VULKAN_HPP_NAMESPACE) #if !defined(VULKAN_HPP_NAMESPACE)
#define VULKAN_HPP_NAMESPACE vk #define VULKAN_HPP_NAMESPACE vk
#endif #endif
@ -5051,23 +5073,21 @@ static const std::string constExpressionArrayCopy = R"(
)"; )";
static const std::string exceptions = R"( static const std::string exceptions = R"(
#if defined(_MSC_VER) && (_MSC_VER == 1800)
# define noexcept _NOEXCEPT
#endif
class ErrorCategoryImpl : public std::error_category class ErrorCategoryImpl : public std::error_category
{ {
public: public:
virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; } virtual const char* name() const VULKAN_HPP_NOEXCEPT override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); } virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
}; };
class Error class Error
{ {
public: public:
virtual ~Error() = default; Error() VULKAN_HPP_NOEXCEPT = default;
Error(const Error&) VULKAN_HPP_NOEXCEPT = default;
virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
virtual const char* what() const noexcept = 0; virtual const char* what() const VULKAN_HPP_NOEXCEPT = 0;
}; };
class LogicError : public Error, public std::logic_error class LogicError : public Error, public std::logic_error
@ -5077,9 +5097,8 @@ static const std::string constExpressionArrayCopy = R"(
: Error(), std::logic_error(what) {} : Error(), std::logic_error(what) {}
explicit LogicError( char const * what ) explicit LogicError( char const * what )
: Error(), std::logic_error(what) {} : Error(), std::logic_error(what) {}
virtual ~LogicError() = default;
virtual const char* what() const noexcept { return std::logic_error::what(); } virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::logic_error::what(); }
}; };
class SystemError : public Error, public std::system_error class SystemError : public Error, public std::system_error
@ -5097,27 +5116,22 @@ static const std::string constExpressionArrayCopy = R"(
: Error(), std::system_error(ev, ecat, what) {} : Error(), std::system_error(ev, ecat, what) {}
SystemError( int ev, std::error_category const& ecat, char const * what) SystemError( int ev, std::error_category const& ecat, char const * what)
: Error(), std::system_error(ev, ecat, what) {} : Error(), std::system_error(ev, ecat, what) {}
virtual ~SystemError() = default;
virtual const char* what() const noexcept { return std::system_error::what(); } virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::system_error::what(); }
}; };
#if defined(_MSC_VER) && (_MSC_VER == 1800) VULKAN_HPP_INLINE const std::error_category& errorCategory() VULKAN_HPP_NOEXCEPT
# undef noexcept
#endif
VULKAN_HPP_INLINE const std::error_category& errorCategory()
{ {
static ErrorCategoryImpl instance; static ErrorCategoryImpl instance;
return instance; return instance;
} }
VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
{ {
return std::error_code(static_cast<int>(e), errorCategory()); return std::error_code(static_cast<int>(e), errorCategory());
} }
VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
{ {
return std::error_condition(static_cast<int>(e), errorCategory()); return std::error_condition(static_cast<int>(e), errorCategory());
} }
@ -5164,17 +5178,25 @@ namespace std
)"; )";
static const std::string structResultValue = R"( static const std::string structResultValue = R"(
template <typename T> void ignore(T const&) {} template <typename T> void ignore(T const&) VULKAN_HPP_NOEXCEPT {}
template <typename T> template <typename T>
struct ResultValue struct ResultValue
{ {
#ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(value(v)))
#else
ResultValue( Result r, T & v ) ResultValue( Result r, T & v )
#endif
: result( r ) : result( r )
, value( v ) , value( v )
{} {}
#ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(value(std::move(v))))
#else
ResultValue( Result r, T && v ) ResultValue( Result r, T && v )
#endif
: result( r ) : result( r )
, value( std::move( v ) ) , value( std::move( v ) )
{} {}
@ -5182,7 +5204,7 @@ namespace std
Result result; Result result;
T value; T value;
operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); } operator std::tuple<Result&, T&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
}; };
template <typename T> template <typename T>

16265
vulkan/vulkan.hpp
View File

File diff suppressed because it is too large Load Diff