mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1074 from asuessenbach/refactor

Browse Source 
Refactor RAII-handle constructor generation.
This commit is contained in:
Andreas Süßenbach 2021-09-21 10:00:26 +02:00 committed by GitHub
commit 0eea598f6f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 157 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
VulkanHppGenerator.cpp
View File

@ -7190,65 +7190,158 @@ std::pair<std::string, std::string> VulkanHppGenerator::generateRAIIHandleConstr
std::string const & enter, std::string const & enter,
std::string const & leave ) const std::string const & leave ) const
{ {
auto handleParamIt = std::find_if( constructorIt->second.params.begin(), std::string singularConstructor, arrayConstructor;
constructorIt->second.params.end(), if ( constructorIt->second.returnType == "VkResult" )
[&handle]( ParamData const & pd ) { return pd.type.type == handle.first; } );
assert( handleParamIt != constructorIt->second.params.end() && handleParamIt->type.isNonConstPointer() );
std::string singularConstructor, arrayConstructor, throwDetail;
bool constructedConstructor = false;
if ( handleParamIt->len.empty() )
{ {
if ( constructorIt->second.returnType == "void" ) assert( !constructorIt->second.successCodes.empty() );
{ assert( constructorIt->second.successCodes[0] == "VK_SUCCESS" );
singularConstructor = generateRAIIHandleConstructorVoid( handle, constructorIt, enter, leave ); switch ( constructorIt->second.successCodes.size() )
constructedConstructor = true;
}
else if ( ( constructorIt->second.returnType == "VkResult" ) && ( constructorIt->second.successCodes.size() == 1 ) )
{ {
case 1:
if ( !constructorIt->second.errorCodes.empty() ) if ( !constructorIt->second.errorCodes.empty() )
{ {
std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( constructorIt->second.params );
if ( returnParamIndices.size() == 1 )
{
assert( isHandleType( constructorIt->second.params[returnParamIndices[0]].type.type ) );
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( constructorIt->second.params );
switch ( vectorParamIndices.size() )
{
case 0:
singularConstructor = generateRAIIHandleConstructorResult( handle, constructorIt, enter, leave ); singularConstructor = generateRAIIHandleConstructorResult( handle, constructorIt, enter, leave );
constructedConstructor = true; break;
} case 1:
else if ( returnParamIndices[0] == vectorParamIndices.begin()->first )
{ {
throwDetail = "\n\tReason: no errorcodes provided."; if ( isLenByStructMember( constructorIt->second.params[vectorParamIndices.begin()->first].len,
} constructorIt->second.params[vectorParamIndices.begin()->second] ) )
}
}
else
{
auto lenParamIt =
std::find_if( constructorIt->second.params.begin(),
constructorIt->second.params.end(),
[&handleParamIt]( ParamData const & pd ) { return pd.name == handleParamIt->len; } );
if ( ( lenParamIt != constructorIt->second.params.end() ) && lenParamIt->type.isNonConstPointer() &&
( constructorIt->second.successCodes.size() == 2 ) &&
( constructorIt->second.successCodes[0] == "VK_SUCCESS" ) &&
( constructorIt->second.successCodes[1] == "VK_INCOMPLETE" ) )
{ {
auto handleParamIt = constructorIt->second.params.begin() + returnParamIndices[0];
arrayConstructor = arrayConstructor =
generateRAIIHandleConstructorEnumerate( handle, constructorIt, handleParamIt, lenParamIt, enter, leave ); generateRAIIHandleConstructorVector( handle, constructorIt, handleParamIt, enter, leave );
} }
else }
break;
case 2:
std::tie( singularConstructor, arrayConstructor ) = generateRAIIHandleConstructor1Return2Vector(
handle, constructorIt, enter, leave, returnParamIndices[0], vectorParamIndices );
break;
}
}
}
break;
case 2:
if ( !constructorIt->second.errorCodes.empty() )
{ {
arrayConstructor = generateRAIIHandleConstructorVector( handle, constructorIt, handleParamIt, enter, leave ); std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( constructorIt->second.params );
if ( ( lenParamIt != constructorIt->second.params.end() ) && switch ( returnParamIndices.size() )
!checkEquivalentSingularConstructor( handle.second.constructorIts, constructorIt, lenParamIt ) ) {
case 1:
assert( isHandleType( constructorIt->second.params[returnParamIndices[0]].type.type ) );
{
std::map<size_t, size_t> vectorParamIndices =
determineVectorParamIndices( constructorIt->second.params );
if ( vectorParamIndices.size() == 2 )
{
std::tie( singularConstructor, arrayConstructor ) = generateRAIIHandleConstructor1Return2Vector(
handle, constructorIt, enter, leave, returnParamIndices[0], vectorParamIndices );
}
}
break;
case 2:
if ( constructorIt->second.params[returnParamIndices[0]].type.type == "uint32_t" )
{
assert( isHandleType( constructorIt->second.params[returnParamIndices[1]].type.type ) );
std::map<size_t, size_t> vectorParamIndices =
determineVectorParamIndices( constructorIt->second.params );
if ( vectorParamIndices.size() == 1 )
{
if ( returnParamIndices[0] == vectorParamIndices.begin()->second )
{
assert( returnParamIndices[1] == vectorParamIndices.begin()->first );
assert( constructorIt->second.successCodes[1] == "VK_INCOMPLETE" );
auto lenParamIt = constructorIt->second.params.begin() + returnParamIndices[0];
auto handleParamIt = constructorIt->second.params.begin() + returnParamIndices[1];
arrayConstructor = generateRAIIHandleConstructorEnumerate(
handle, constructorIt, handleParamIt, lenParamIt, enter, leave );
}
}
}
break;
}
}
break;
case 4:
if ( !constructorIt->second.errorCodes.empty() )
{
std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( constructorIt->second.params );
if ( returnParamIndices.size() == 1 )
{
assert( isHandleType( constructorIt->second.params[returnParamIndices[0]].type.type ) );
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( constructorIt->second.params );
if ( vectorParamIndices.size() == 2 )
{
std::tie( singularConstructor, arrayConstructor ) = generateRAIIHandleConstructor1Return2Vector(
handle, constructorIt, enter, leave, returnParamIndices[0], vectorParamIndices );
}
}
}
break;
}
}
else if ( constructorIt->second.returnType == "void" )
{
assert( constructorIt->second.successCodes.empty() && constructorIt->second.errorCodes.empty() );
std::vector<size_t> returnParamIndices = determineNonConstPointerParamIndices( constructorIt->second.params );
if ( returnParamIndices.size() == 1 )
{
assert( isHandleType( constructorIt->second.params[returnParamIndices[0]].type.type ) );
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( constructorIt->second.params );
if ( vectorParamIndices.empty() )
{
singularConstructor = generateRAIIHandleConstructorVoid( handle, constructorIt, enter, leave );
}
}
}
if ( singularConstructor.empty() && arrayConstructor.empty() )
{
throw std::runtime_error( "Never encountered a function like <" + constructorIt->first + "> !" );
}
return std::make_pair( singularConstructor, arrayConstructor );
}
std::pair<std::string, std::string> VulkanHppGenerator::generateRAIIHandleConstructor1Return2Vector(
std::pair<std::string, HandleData> const & handle,
std::map<std::string, CommandData>::const_iterator constructorIt,
std::string const & enter,
std::string const & leave,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ) const
{
if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first )
{
if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second )
{
if ( constructorIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" )
{
if ( isStructureChainAnchor( constructorIt->second.params[vectorParamIndices.begin()->first].type.type ) )
{
std::string singularConstructor;
auto lenParamIt = constructorIt->second.params.begin() + vectorParamIndices.begin()->second;
auto handleParamIt = constructorIt->second.params.begin() + std::next( vectorParamIndices.begin() )->first;
if ( !checkEquivalentSingularConstructor( handle.second.constructorIts, constructorIt, lenParamIt ) )
{ {
singularConstructor = singularConstructor =
generateRAIIHandleConstructorVectorSingular( handle, constructorIt, handleParamIt, enter, leave ); generateRAIIHandleConstructorVectorSingular( handle, constructorIt, handleParamIt, enter, leave );
} }
return std::make_pair(
singularConstructor,
generateRAIIHandleConstructorVector( handle, constructorIt, handleParamIt, enter, leave ) );
} }
constructedConstructor = true;
} }
if ( !constructedConstructor )
{
throw std::runtime_error( "Never encountered a constructor function like " + constructorIt->first + " !" +
throwDetail );
} }
return std::make_pair( singularConstructor, arrayConstructor ); }
return std::make_pair( "", "" );
} }
std::string VulkanHppGenerator::generateStructForwardDeclarations( std::vector<RequireData> const & requireData, std::string VulkanHppGenerator::generateStructForwardDeclarations( std::vector<RequireData> const & requireData,

7
VulkanHppGenerator.hpp
View File

@ -853,6 +853,13 @@ private:
std::map<std::string, CommandData>::const_iterator constructorIt, std::map<std::string, CommandData>::const_iterator constructorIt,
std::string const & enter, std::string const & enter,
std::string const & leave ) const; std::string const & leave ) const;
std::pair<std::string, std::string>
generateRAIIHandleConstructor1Return2Vector( std::pair<std::string, HandleData> const & handle,
std::map<std::string, CommandData>::const_iterator constructorIt,
std::string const & enter,
std::string const & leave,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateStructForwardDeclarations( std::vector<RequireData> const & requireData, std::string generateStructForwardDeclarations( std::vector<RequireData> const & requireData,
std::string const & title ) const; std::string const & title ) const;