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

Combine two types of commands into one generation function.

Browse Source
This commit is contained in:
asuessenbach 2022-03-02 17:57:36 +01:00
parent 9cdca0a90d
commit 02cd5ee1c9
2 changed files with 73 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
VulkanHppGenerator.cpp
View File

@ -2195,7 +2195,7 @@ std::set<size_t> VulkanHppGenerator::determineVoidPointerParams( std::vector<Par
for ( size_t i = 0; i < params.size(); i++ ) for ( size_t i = 0; i < params.size(); i++ )
{ {
if ( !params[i].type.isValue() && params[i].type.type == "void" ) if ( !params[i].type.isValue() && ( params[i].type.type == "void" ) && ( params[i].type.postfix != "**" ) )
{ {
voidPointerParams.insert( i ); voidPointerParams.insert( i );
} }
@ -3659,64 +3659,79 @@ std::string VulkanHppGenerator::generateCommandResultGetSingularAndValue( std::s
} }
} }
std::string VulkanHppGenerator::generateCommandResultGetValue( std::string VulkanHppGenerator::generateCommandResultGetValue( std::string const & name,
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParams,
size_t returnParam,
bool singular ) const
{ {
assert( commandData.returnType == "VkResult" ); assert( commandData.returnType == "VkResult" );
std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, { returnParam }, false ); std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, singular );
std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, false, false, true ); // special handling for vkGetMemoryHostPointerPropertiesEXT: here, we really need to stick with the const void * parameter !
std::set<size_t> templatedParams = ( name == "vkGetMemoryHostPointerPropertiesEXT" ) ? std::set<size_t>() : determineVoidPointerParams( commandData.params );
std::set<size_t> singularParams = singular ? determineSingularParams( returnParam, vectorParams ) : std::set<size_t>();
std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, templatedParams, definition, false, false, true );
std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); if ( singular )
std::string returnBaseType = trimEnd( stripPostfix( commandData.params[returnParam].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) );
std::string typenameT;
if ( returnBaseType == "void" )
{ {
returnBaseType = "T"; commandName = stripPluralS( commandName );
typenameT = "typename T, ";
} }
std::string returnType = generateReturnType( commandData.successCodes, returnBaseType ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false );
std::string dataType = ( templatedParams.find( returnParam ) != templatedParams.end() )
? ( stripPrefix( commandData.params[returnParam].name, "p" ) + "Type" )
: stripPostfix( commandData.params[returnParam].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" );
std::string returnType = generateReturnType( commandData.successCodes, dataType );
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <${typenameT}typename Dispatch> R"( template <${argumentTemplates}typename Dispatch>
${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} )${const} ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} )${const}
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
${returnBaseType} ${returnValueName}; ${dataType} ${dataVariable};
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${returnValueName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); return createResultValue( result, ${dataVariable}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})"; })";
std::string dataVariable = startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) );
if ( singular )
{
dataVariable = stripPluralS( dataVariable );
}
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, {}, false ) }, { "argumentTemplates", argumentTemplates },
{ "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, singularParams, templatedParams, false ) },
{ "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, { "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "const", commandData.handle.empty() ? "" : " const" }, { "const", commandData.handle.empty() ? "" : " const" },
{ "commandName", commandName }, { "commandName", commandName },
{ "returnBaseType", returnBaseType }, { "dataType", dataType },
{ "returnValueName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) }, { "dataVariable", dataVariable },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType }, { "returnType", returnType },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
{ "typenameT", typenameT },
{ "vkCommand", name } } ); { "vkCommand", name } } );
} }
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <${typenameT}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> R"( template <${argumentTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
${nodiscard}${returnType} ${commandName}( ${argumentList} )${const};)"; ${nodiscard}${returnType} ${commandName}( ${argumentList} )${const};)";
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
{ "const", commandData.handle.empty() ? "" : " const" }, { "const", commandData.handle.empty() ? "" : " const" },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType }, { "returnType", returnType } } );
{ "typenameT", typenameT } } );
} }
} }
@ -4098,74 +4113,6 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUniqueSin
} }
} }
std::string VulkanHppGenerator::generateCommandResultGetVectorSingular( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParams,
size_t returnParam ) const
{
assert( commandData.returnType == "VkResult" );
std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, true );
std::set<size_t> templatedParams = determineVoidPointerParams( commandData.params );
std::set<size_t> singularParams = determineSingularParams( returnParam, vectorParams );
std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, { returnParam }, definition, false, false, true );
std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false );
std::string dataType;
if ( commandData.params[returnParam].type.type == "void" )
{
dataType = stripPrefix( commandData.params[returnParam].name, "p" ) + "Type";
}
else
{
dataType = stripPostfix( commandData.params[returnParam].type.compose( "VULKAN_HPP_NAMESPACE" ), " *" );
}
std::string returnType = generateReturnType( commandData.successCodes, dataType );
if ( definition )
{
std::string const functionTemplate =
R"( template <${argumentTemplates}typename Dispatch>
${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
${dataType} ${dataVariable};
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${dataVariable}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})";
return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, singularParams, {}, false ) },
{ "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName },
{ "dataVariable", stripPluralS( startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) ) },
{ "dataType", dataType },
{ "nodiscard", nodiscard },
{ "returnType", returnType },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
{ "vkCommand", name } } );
}
else
{
std::string const functionTemplate =
R"( template <${argumentTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName },
{ "nodiscard", nodiscard },
{ "returnType", returnType } } );
}
}
std::string VulkanHppGenerator::generateCommandResultMultiSuccessNoErrors( std::string const & name, std::string VulkanHppGenerator::generateCommandResultMultiSuccessNoErrors( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -4220,7 +4167,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ) );
} }
} }
} }
@ -4243,7 +4190,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) );
@ -4258,9 +4205,10 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu
std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params ); std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params );
if ( vectorParams.empty() ) if ( vectorParams.empty() )
{ {
return generateCommandSetStandardEnhanced( definition, return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ) );
} }
} }
return ""; return "";
@ -4430,9 +4378,10 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params ); std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params );
if ( vectorParams.empty() ) if ( vectorParams.empty() )
{ {
return generateCommandSetStandardEnhancedChained( definition, return generateCommandSetStandardEnhancedChained(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParam ), generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetChain( name, commandData, initialSkipCount, definition, returnParam ) ); generateCommandResultGetChain( name, commandData, initialSkipCount, definition, returnParam ) );
} }
return ""; return "";
@ -4445,9 +4394,10 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
switch ( vectorParams.size() ) switch ( vectorParams.size() )
{ {
case 0: case 0:
return generateCommandSetStandardEnhancedUnique( definition, return generateCommandSetStandardEnhancedUnique(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParam ), generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetHandleUnique( name, commandData, initialSkipCount, definition, returnParam ) ); generateCommandResultGetHandleUnique( name, commandData, initialSkipCount, definition, returnParam ) );
break; break;
case 1: case 1:
@ -4504,7 +4454,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) );
@ -4522,9 +4472,10 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
switch ( vectorParams.size() ) switch ( vectorParams.size() )
{ {
case 0: case 0:
return generateCommandSetStandardEnhanced( definition, return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ) );
case 2: case 2:
return generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors( name, commandData, initialSkipCount, definition, returnParam, vectorParams ); return generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors( name, commandData, initialSkipCount, definition, returnParam, vectorParams );
break; break;
@ -4554,7 +4505,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ),
generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ) );
} }
} }
} }
@ -4569,9 +4520,10 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
switch ( vectorParams.size() ) switch ( vectorParams.size() )
{ {
case 0: case 0:
return generateCommandSetStandardEnhanced( definition, return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ) );
break; break;
case 1: case 1:
if ( returnParam == vectorParams.begin()->first ) if ( returnParam == vectorParams.begin()->first )
@ -4582,7 +4534,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ) );
} }
} }
break; break;
@ -4601,7 +4553,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ),
generateCommandResultGetVectorSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); generateCommandResultGetValue( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ) );
} }
} }
} }

15
VulkanHppGenerator.hpp
View File

@ -490,8 +490,13 @@ private:
bool definition, bool definition,
std::vector<size_t> const & returnParamIndices, std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices ) const; std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateCommandResultGetValue( std::string generateCommandResultGetValue( std::string const & name,
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const; CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParams,
size_t returnParam,
bool singular ) const;
std::string generateCommandResultGetVector( std::string const & name, std::string generateCommandResultGetVector( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -525,12 +530,6 @@ private:
bool definition, bool definition,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParam ) const; size_t returnParam ) const;
std::string generateCommandResultGetVectorSingular( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParam ) const;
std::string std::string
generateCommandResultMultiSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const; generateCommandResultMultiSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
std::string std::string