TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-08 19:36:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

Minor cleanup work (#2220)

Browse Source
This commit is contained in:
Andreas Süßenbach 2025-07-18 09:01:07 +02:00 committed by GitHub
parent d3a3c6321f
commit b59d87d696
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 43 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
VideoHppGenerator.cpp
View File

@ -457,12 +457,12 @@ std::string VideoHppGenerator::generateStructMembers( std::pair<std::string, Str
} }
else if ( member.arraySizes.empty() ) else if ( member.arraySizes.empty() )
{ {
type = member.type.compose( "VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE", "StdVideo" ); type = member.type.compose( "StdVideo", "VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE" );
} }
else else
{ {
assert( member.type.prefix.empty() && member.type.postfix.empty() ); assert( member.type.prefix.empty() && member.type.postfix.empty() );
type = generateStandardArrayWrapper( member.type.compose( "VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE" ), member.arraySizes ); type = generateStandardArrayWrapper( member.type.compose( "" ), member.arraySizes );
} }
members += type + " " + member.name; members += type + " " + member.name;

74
VulkanHppGenerator.cpp
View File

@ -41,7 +41,6 @@ namespace
typename std::vector<T>::iterator findByNameOrAlias( std::vector<T> & values, std::string const & name ); typename std::vector<T>::iterator findByNameOrAlias( std::vector<T> & values, std::string const & name );
std::string generateCArraySizes( std::vector<std::string> const & sizes ); std::string generateCArraySizes( std::vector<std::string> const & sizes );
std::string generateList( std::vector<std::string> const & elements, std::string const & prefix, std::string const & separator ); std::string generateList( std::vector<std::string> const & elements, std::string const & prefix, std::string const & separator );
std::string generateNamespacedType( std::string const & type );
std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bool multiErrorCodes ); std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bool multiErrorCodes );
std::string generateStandardArray( std::string const & type, std::vector<std::string> const & sizes ); std::string generateStandardArray( std::string const & type, std::vector<std::string> const & sizes );
bool isAllUpper( std::string const & name ); bool isAllUpper( std::string const & name );
@ -1661,12 +1660,12 @@ std::vector<std::string> VulkanHppGenerator::determineDataTypes( std::vector<Vul
else if ( ( vectorParamIt != vectorParams.end() ) && vectorParamIt->second.byStructure ) else if ( ( vectorParamIt != vectorParams.end() ) && vectorParamIt->second.byStructure )
{ {
dataTypes.push_back( dataTypes.push_back(
trimEnd( stripPostfix( vectorMemberByStructure( params[rp].type.type ).type.compose2( raii ? "VULKAN_HPP_NAMESPACE::" : "" ), "*" ) ) ); trimEnd( stripPostfix( vectorMemberByStructure( params[rp].type.type ).type.compose( "Vk", raii ? "VULKAN_HPP_NAMESPACE" : "" ), "*" ) ) );
} }
else else
{ {
dataTypes.push_back( dataTypes.push_back( trimEnd(
trimEnd( stripPostfix( params[rp].type.compose2( ( raii && m_handles.contains( params[rp].type.type ) ) ? "VULKAN_HPP_NAMESPACE::" : "" ), "*" ) ) ); stripPostfix( params[rp].type.compose( "Vk", ( raii && m_handles.contains( params[rp].type.type ) ) ? "VULKAN_HPP_NAMESPACE" : "" ), "*" ) ) );
} }
} }
return dataTypes; return dataTypes;
@ -2273,7 +2272,7 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
{ {
bool hasDefaultAssignment = false; bool hasDefaultAssignment = false;
std::string composedType = params[i].type.compose2( ( raii && m_handles.contains( params[i].type.type ) ) ? "VULKAN_HPP_NAMESPACE::" : "" ); std::string composedType = params[i].type.compose( "Vk", ( raii && m_handles.contains( params[i].type.type ) ) ? "VULKAN_HPP_NAMESPACE" : "" );
if ( singularParams.contains( i ) ) if ( singularParams.contains( i ) )
{ {
@ -2431,7 +2430,7 @@ std::string VulkanHppGenerator::generateArgumentListStandard( std::vector<ParamD
{ {
// parameters named "objectType" collide with the member variable -> append an _ to here // parameters named "objectType" collide with the member variable -> append an _ to here
std::string paramName = ( definition && ( params[i].name == "objectType" ) ) ? "objectType_" : params[i].name; std::string paramName = ( definition && ( params[i].name == "objectType" ) ) ? "objectType_" : params[i].name;
argumentList += params[i].type.compose2( "" ) + " " + paramName + generateCArraySizes( params[i].arraySizes ) + ", "; argumentList += params[i].type.compose( "Vk" ) + " " + paramName + generateCArraySizes( params[i].arraySizes ) + ", ";
} }
} }
if ( withDispatcher ) if ( withDispatcher )
@ -2499,7 +2498,7 @@ ${basetypes}
// filter out VkFlags and VkFlags64, as they are mapped to our own Flags class, and basetypes without any type information // filter out VkFlags and VkFlags64, as they are mapped to our own Flags class, and basetypes without any type information
if ( ( baseType.first != "VkFlags" ) && ( baseType.first != "VkFlags64" ) && !baseType.second.typeInfo.type.empty() ) if ( ( baseType.first != "VkFlags" ) && ( baseType.first != "VkFlags64" ) && !baseType.second.typeInfo.type.empty() )
{ {
basetypes += " using " + stripPrefix( baseType.first, "Vk" ) + " = " + baseType.second.typeInfo.compose( "VULKAN_HPP_NAMESPACE" ) + ";\n"; basetypes += " using " + stripPrefix( baseType.first, "Vk" ) + " = " + baseType.second.typeInfo.compose( "Vk", "VULKAN_HPP_NAMESPACE" ) + ";\n";
} }
} }
@ -2835,7 +2834,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedConstPointer( ParamD
if ( param.type.type == "void" ) if ( param.type.type == "void" )
{ {
argument = argument =
templatedParams.contains( paramIndex ) ? "reinterpret_cast<" + param.type.compose( "VULKAN_HPP_NAMESPACE" ) + ">( &" + name + " )" : param.name; templatedParams.contains( paramIndex ) ? "reinterpret_cast<" + param.type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ) + ">( &" + name + " )" : param.name;
} }
else if ( param.optional ) else if ( param.optional )
{ {
@ -3128,7 +3127,7 @@ std::string VulkanHppGenerator::generateCallSequence( std::string const &
{ {
assert( vectorParams.size() == 1 ); assert( vectorParams.size() == 1 );
// chained data needs some more handling!! // chained data needs some more handling!!
std::string vectorElementType = stripPostfix( commandData.params[vectorParamIt->first].type.compose2( "" ), " *" ); std::string vectorElementType = stripPostfix( commandData.params[vectorParamIt->first].type.compose( "Vk" ), " *" );
if ( commandData.returnType == "VkResult" ) if ( commandData.returnType == "VkResult" )
{ {
@ -6143,7 +6142,7 @@ std::string VulkanHppGenerator::generateDataDeclarations1Return( CommandData con
return replaceWithMap( dataDeclarationTemplate, return replaceWithMap( dataDeclarationTemplate,
{ { "dataType", dataType }, { { "dataType", dataType },
{ "returnVariable", returnVariable }, { "returnVariable", returnVariable },
{ "structType", stripPostfix( commandData.params[vectorParamIt->first].type.compose2( "" ), "*" ) }, { "structType", stripPostfix( commandData.params[vectorParamIt->first].type.compose( "Vk" ), "*" ) },
{ "structVariable", startLowerCase( stripPrefix( commandData.params[vectorParamIt->first].name, "p" ) ) }, { "structVariable", startLowerCase( stripPrefix( commandData.params[vectorParamIt->first].name, "p" ) ) },
{ "vectorAllocator", stripPrefix( vectorAllocator, "," ) } } ); { "vectorAllocator", stripPrefix( vectorAllocator, "," ) } } );
} }
@ -6436,7 +6435,7 @@ std::string VulkanHppGenerator::generateDataPreparation( CommandData const &
assert( !vectorParams.contains( returnParams[0] ) ); assert( !vectorParams.contains( returnParams[0] ) );
assert( ( vectorParamIt != vectorParams.end() ) && ( vectorParamIt->second.lenParam == returnParams[0] ) ); assert( ( vectorParamIt != vectorParams.end() ) && ( vectorParamIt->second.lenParam == returnParams[0] ) );
std::string vectorElementType = stripPostfix( commandData.params[vectorParamIt->first].type.compose2( "" ), " *" ); std::string vectorElementType = stripPostfix( commandData.params[vectorParamIt->first].type.compose( "Vk" ), " *" );
if ( enumerating ) if ( enumerating )
{ {
@ -8066,7 +8065,7 @@ std::string VulkanHppGenerator::generateFuncPointer( std::pair<std::string, Func
{ {
for ( auto const & argument : funcPointer.second.arguments ) for ( auto const & argument : funcPointer.second.arguments )
{ {
funcPointerArguments += argument.type.compose2( "" ) + " " + argument.name + ", "; funcPointerArguments += argument.type.compose( "Vk" ) + " " + argument.name + ", ";
} }
assert( !funcPointerArguments.empty() ); assert( !funcPointerArguments.empty() );
funcPointerArguments.pop_back(); funcPointerArguments.pop_back();
@ -8081,7 +8080,7 @@ std::string VulkanHppGenerator::generateFuncPointer( std::pair<std::string, Func
replaceWithMap( funcPointerTemplate, replaceWithMap( funcPointerTemplate,
{ { "funcPointerArguments", funcPointerArguments }, { { "funcPointerArguments", funcPointerArguments },
{ "funcPointerName", stripPrefix( funcPointer.first, "PFN_vk" ) }, { "funcPointerName", stripPrefix( funcPointer.first, "PFN_vk" ) },
{ "returnType", funcPointer.second.returnType.compose2( "" ) } } ) + { "returnType", funcPointer.second.returnType.compose( "Vk" ) } } ) +
leave; leave;
listedStructs.insert( funcPointer.first ); listedStructs.insert( funcPointer.first );
@ -9769,11 +9768,11 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArgument( ParamData
assert( !param.optional ); assert( !param.optional );
if ( param.arraySizes.empty() ) if ( param.arraySizes.empty() )
{ {
argument = param.type.compose( "VULKAN_HPP_NAMESPACE" ) + " "; argument = param.type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ) + " ";
} }
else else
{ {
argument = generateStandardArray( param.type.compose( "VULKAN_HPP_NAMESPACE" ), param.arraySizes ) + " const & "; argument = generateStandardArray( param.type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ), param.arraySizes ) + " const & ";
} }
argument += param.name; argument += param.name;
} }
@ -10378,8 +10377,9 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
} }
else if ( destructorParam.type.type == handle.first ) else if ( destructorParam.type.type == handle.first )
{ {
assert( handle.first.starts_with( "Vk" ) );
memberName = handleName; memberName = handleName;
memberType = generateNamespacedType( handle.first ); memberType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( handle.first, "Vk" );
} }
else if ( std::ranges::none_of( handle.second.destructorIt->second.params, else if ( std::ranges::none_of( handle.second.destructorIt->second.params,
[&destructorParam]( ParamData const & pd ) { return pd.lenExpression == destructorParam.name; } ) ) [&destructorParam]( ParamData const & pd ) { return pd.lenExpression == destructorParam.name; } ) )
@ -10390,7 +10390,7 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
name = startLowerCase( stripPrefix( name, "p" ) ); name = startLowerCase( stripPrefix( name, "p" ) );
} }
memberName = name; memberName = name;
memberType = destructorParam.type.compose2( m_handles.contains( destructorParam.type.type ) ? "VULKAN_HPP_NAMESPACE::" : "" ); memberType = destructorParam.type.compose( "Vk", m_handles.contains( destructorParam.type.type ) ? "VULKAN_HPP_NAMESPACE" : "" );
} }
if ( !memberName.empty() ) if ( !memberName.empty() )
{ {
@ -10431,7 +10431,8 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
clearMembers += "\n m_" + handleName + " = nullptr;"; clearMembers += "\n m_" + handleName + " = nullptr;";
moveConstructorInitializerList += "m_" + handleName + "( exchange( rhs.m_" + handleName + ", {} ) ), "; moveConstructorInitializerList += "m_" + handleName + "( exchange( rhs.m_" + handleName + ", {} ) ), ";
moveAssignmentInstructions += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );"; moveAssignmentInstructions += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
memberVariables += "\n " + generateNamespacedType( handle.first ) + " m_" + handleName + " = {};"; assert( handle.first.starts_with( "Vk" ) );
memberVariables += "\n VULKAN_HPP_NAMESPACE::" + stripPrefix( handle.first, "Vk" ) + " m_" + handleName + " = {};";
swapMembers += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );"; swapMembers += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
} }
@ -11357,7 +11358,7 @@ std::string VulkanHppGenerator::generateStructCompareOperators( std::pair<std::s
assert( ( member.arraySizes.size() == 1 ) && ( member.lenExpressions.size() == 1 ) ); assert( ( member.arraySizes.size() == 1 ) && ( member.lenExpressions.size() == 1 ) );
assert( std::ranges::any_of( structData.second.members, [&member]( MemberData const & m ) { return m.name == member.lenExpressions[0]; } ) ); assert( std::ranges::any_of( structData.second.members, [&member]( MemberData const & m ) { return m.name == member.lenExpressions[0]; } ) );
std::string type = member.type.compose2( "" ); std::string type = member.type.compose( "Vk" );
static const std::string compareMemberTemplate = R"(( memcmp( ${name}, rhs.${name}, ${count} * sizeof( ${type} ) ) == 0 ))"; static const std::string compareMemberTemplate = R"(( memcmp( ${name}, rhs.${name}, ${count} * sizeof( ${type} ) ) == 0 ))";
compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "type", type } } ); compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "type", type } } );
@ -11478,7 +11479,7 @@ std::string VulkanHppGenerator::generateStructConstructors( std::pair<std::strin
if ( pNextIt != structData.second.members.end() ) if ( pNextIt != structData.second.members.end() )
{ {
// add pNext as a last optional argument to the constructor // add pNext as a last optional argument to the constructor
arguments.push_back( pNextIt->type.compose2( "" ) + " pNext_ = nullptr" ); arguments.push_back( pNextIt->type.compose( "Vk" ) + " pNext_ = nullptr" );
} }
std::string str = replaceWithMap( constructors, std::string str = replaceWithMap( constructors,
@ -11578,7 +11579,7 @@ ${byString}
assert( mit->type.isPointer() || !mit->arraySizes.empty() ); assert( mit->type.isPointer() || !mit->arraySizes.empty() );
std::string argumentName = ( mit->type.isPointer() ? startLowerCase( stripPrefix( mit->name, "p" ) ) : mit->name ) + "_"; std::string argumentName = ( mit->type.isPointer() ? startLowerCase( stripPrefix( mit->name, "p" ) ) : mit->name ) + "_";
std::string argumentType = mit->type.compose2( "" ); std::string argumentType = mit->type.compose( "Vk" );
if ( mit->type.isPointer() ) if ( mit->type.isPointer() )
{ {
argumentType = trimEnd( stripPostfix( argumentType, "*" ) ); argumentType = trimEnd( stripPostfix( argumentType, "*" ) );
@ -11668,7 +11669,7 @@ ${byString}
if ( pNextIt != structData.second.members.end() ) if ( pNextIt != structData.second.members.end() )
{ {
// add pNext as a last optional argument to the constructor // add pNext as a last optional argument to the constructor
arguments.push_back( pNextIt->type.compose( "VULKAN_HPP_NAMESPACE" ) + " pNext_ = nullptr" ); arguments.push_back( pNextIt->type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ) + " pNext_ = nullptr" );
} }
static const std::string constructorTemplate = R"( static const std::string constructorTemplate = R"(
@ -11702,11 +11703,11 @@ std::string VulkanHppGenerator::generateStructConstructorArgument( MemberData co
} }
else if ( memberData.arraySizes.empty() ) else if ( memberData.arraySizes.empty() )
{ {
str += memberData.type.compose2( "" ) + " "; str += memberData.type.compose( "Vk" ) + " ";
} }
else else
{ {
str += generateStandardArray( memberData.type.compose2( "" ), memberData.arraySizes ) + " const & "; str += generateStandardArray( memberData.type.compose( "Vk" ), memberData.arraySizes ) + " const & ";
} }
str += memberData.name + "_"; str += memberData.name + "_";
@ -12242,12 +12243,12 @@ std::tuple<std::string, std::string, std::string, std::string>
} }
else if ( member.arraySizes.empty() ) else if ( member.arraySizes.empty() )
{ {
type = member.type.compose2( "" ); type = member.type.compose( "Vk" );
} }
else else
{ {
assert( member.type.prefix.empty() && member.type.postfix.empty() ); assert( member.type.prefix.empty() && member.type.postfix.empty() );
type = generateStandardArrayWrapper( member.type.compose2( "" ), member.arraySizes ); type = generateStandardArrayWrapper( member.type.compose( "Vk" ), member.arraySizes );
} }
members += type + " " + member.name; members += type + " " + member.name;
if ( !member.value.empty() ) if ( !member.value.empty() )
@ -12325,7 +12326,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct
std::string memberType = std::string memberType =
member.type.type.starts_with( "PFN_vk" ) member.type.type.starts_with( "PFN_vk" )
? "PFN_" + stripPrefix( member.type.type, "PFN_vk" ) ? "PFN_" + stripPrefix( member.type.type, "PFN_vk" )
: ( member.arraySizes.empty() ? member.type.compose2( "" ) : generateStandardArray( member.type.compose2( "" ), member.arraySizes ) ); : ( member.arraySizes.empty() ? member.type.compose( "Vk" ) : generateStandardArray( member.type.compose( "Vk" ), member.arraySizes ) );
const bool isReinterpretation = !member.bitCount.empty() && member.type.type.starts_with( "Vk" ); const bool isReinterpretation = !member.bitCount.empty() && member.type.type.starts_with( "Vk" );
std::string assignment; std::string assignment;
if ( isReinterpretation ) if ( isReinterpretation )
@ -12503,7 +12504,7 @@ ${byString}
{ "arraySize", member.arraySizes[0] }, { "arraySize", member.arraySizes[0] },
{ "lenName", lenName }, { "lenName", lenName },
{ "lenValue", lenValue }, { "lenValue", lenValue },
{ "memberType", member.type.compose( "VULKAN_HPP_NAMESPACE" ) }, { "memberType", member.type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ) },
{ "structureName", structureName }, { "structureName", structureName },
{ "templateHeader", templateHeader } } ); { "templateHeader", templateHeader } } );
} }
@ -12701,8 +12702,8 @@ std::string VulkanHppGenerator::generateUnion( std::pair<std::string, StructureD
const bool multipleType = std::any_of( const bool multipleType = std::any_of(
std::next( memberIt ), structure.second.members.end(), [memberIt]( MemberData const & member ) noexcept { return member.type == memberIt->type; } ); std::next( memberIt ), structure.second.members.end(), [memberIt]( MemberData const & member ) noexcept { return member.type == memberIt->type; } );
std::string memberType = ( memberIt->arraySizes.empty() ) std::string memberType = ( memberIt->arraySizes.empty() )
? memberIt->type.compose2( "" ) ? memberIt->type.compose( "Vk" )
: ( "const " + generateStandardArray( memberIt->type.compose( "VULKAN_HPP_NAMESPACE" ), memberIt->arraySizes ) + "&" ); : ( "const " + generateStandardArray( memberIt->type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ), memberIt->arraySizes ) + "&" );
// In a majority of cases this can be constexpr in C++11 as well, however, determining when exactly // In a majority of cases this can be constexpr in C++11 as well, however, determining when exactly
// that is the case is a lot more involved and probably not worth it. // that is the case is a lot more involved and probably not worth it.
@ -12769,12 +12770,12 @@ std::string VulkanHppGenerator::generateUnion( std::pair<std::string, StructureD
{ {
static const std::string memberTemplate = R"( ${memberType} ${memberName}; static const std::string memberTemplate = R"( ${memberType} ${memberName};
)"; )";
members += members += replaceWithMap(
replaceWithMap( memberTemplate, memberTemplate,
{ { "memberName", member.name }, { { "memberName", member.name },
{ "memberType", { "memberType",
member.arraySizes.empty() ? member.type.compose2( "" ) member.arraySizes.empty() ? member.type.compose( "Vk" )
: generateStandardArrayWrapper( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ) } } ); : generateStandardArrayWrapper( member.type.compose( "Vk", "VULKAN_HPP_NAMESPACE" ), member.arraySizes ) } } );
} }
if ( needsUnrestrictedUnions ) if ( needsUnrestrictedUnions )
{ {
@ -17347,11 +17348,6 @@ namespace
return list; return list;
} }
std::string generateNamespacedType( std::string const & type )
{
return type.starts_with( "Vk" ) ? ( "VULKAN_HPP_NAMESPACE::" + stripPrefix( type, "Vk" ) ) : type;
}
std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bool multiErrorCodes ) std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bool multiErrorCodes )
{ {
return ( returnsSomething || multiSuccessCodes ) ? "VULKAN_HPP_NODISCARD " : ( multiErrorCodes ? "VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS " : "" ); return ( returnsSomething || multiSuccessCodes ) ? "VULKAN_HPP_NODISCARD " : ( multiErrorCodes ? "VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS " : "" );

12
XMLHelper.hpp
View File

@ -77,16 +77,12 @@ SyncedMessageHandler messager;
struct TypeInfo struct TypeInfo
{ {
std::string compose( std::string const & nameSpace, std::string const & prefix_ = "Vk" ) const std::string compose( std::string const & prefixToStrip, std::string const & nameSpace = "" ) const
{ {
return prefix + ( prefix.empty() ? "" : " " ) + return prefix + ( prefix.empty() ? "" : " " ) +
( nameSpace.empty() ? type : ( ( ( type.starts_with( prefix_ ) ) ? ( nameSpace + "::" ) : "" ) + stripPrefix( type, prefix_ ) ) ) + ( prefixToStrip.empty()
( postfix.empty() ? "" : " " ) + postfix; ? type
} : ( ( ( type.starts_with( prefixToStrip ) && !nameSpace.empty() ) ? ( nameSpace + "::" ) : "" ) + stripPrefix( type, prefixToStrip ) ) ) +
std::string compose2( std::string prefixToAdd ) const
{
return prefix + ( prefix.empty() ? "" : " " ) + ( type.starts_with( "Vk" ) ? prefixToAdd : "" ) + stripPrefix( type, "Vk" ) +
( postfix.empty() ? "" : " " ) + postfix; ( postfix.empty() ? "" : " " ) + postfix;
} }