static PyObject *pycompmanager_generateComponent(PyObject *self, PyObject *args)
{
int a;
char * moduleName;
char * categoryNameList;
char * flaglist;
if (! PyArg_ParseTuple( args,"ss",&moduleName,&categoryNameList)) return NULL;
a=generateModuleFile(moduleName,categoryNameList);
if(a)
{
printf(" %s component is created\n",moduleName);
return Py_BuildValue("i", a);
}
else
{
printf(" Failure to create %s component\n",moduleName);
return Py_BuildValue("i", a);
}
}
void ReflectionParser::GenerateFiles(void)
{
fs::path sourceRootDirectory( m_options.sourceRoot );
fs::path outputFileDirectory( m_options.outputModuleFileDirectory );
m_moduleFileHeaderTemplate = LoadTemplate( kTemplateModuleFileHeader );
if (!m_moduleFileHeaderTemplate.isValid( ))
{
std::stringstream error;
error << "Unable to compile module file header template." << std::endl;
error << m_moduleFileHeaderTemplate.errorMessage( );
throw std::exception( error.str( ).c_str( ) );
}
m_moduleFileSourceTemplate = LoadTemplate( kTemplateModuleFileSource );
if (!m_moduleFileSourceTemplate.isValid( ))
{
std::stringstream error;
error << "Unable to compile module file source template." << std::endl;
error << m_moduleFileSourceTemplate.errorMessage( );
throw std::exception( error.str( ).c_str( ) );
}
TemplateData moduleFilesData { TemplateData::Type::List };
fs::path metaCacheFileName = m_options.outputModuleFileDirectory;
metaCacheFileName /= ".meta-cache";
auto metaCacheFileExists = exists( metaCacheFileName );
std::string moduleFileCache;
for (auto &file : m_moduleFiles)
{
fs::path filePath( file.first );
// path relative to the source root
auto relativeDir = utils::MakeRelativePath( sourceRootDirectory, filePath )
.replace_extension( "" ).string( );
if (relativeDir.find_first_of( ".." ) != std::string::npos)
continue;
auto outputFile = outputFileDirectory / relativeDir;
auto outputFileHeader = change_extension( outputFile, "Generated.h" );
auto outputFileSource = change_extension( outputFile, "Generated.cpp" );
// module file name
file.second.name = boost::regex_replace(
relativeDir,
kSpecialCharsRegex,
"_"
);
moduleFileCache += file.second.name + '\n';
TemplateData moduleFileData { TemplateData::Type::Object };
moduleFileData[ "name" ] = file.second.name;
moduleFileData[ "header" ] = outputFileHeader.string( );
moduleFilesData << moduleFileData;
// if the generated file header doesn't exist, we need to regenerate
if (m_options.forceRebuild || !metaCacheFileExists || !exists( outputFileHeader ))
{
generateModuleFile( outputFileHeader, outputFileSource, file.first, file.second );
continue;
}
auto lastSourceWrite = last_write_time( filePath );
auto lastGeneratedWrite = last_write_time( outputFileHeader );
// if the generated file is older than the source file, we need to regenerate
if (lastSourceWrite > lastGeneratedWrite)
generateModuleFile( outputFileHeader, outputFileSource, file.first, file.second );
}
fs::path moduleCacheFileName = m_options.outputModuleFileDirectory;
moduleCacheFileName /= ".meta-cache";
if (!m_options.forceRebuild && metaCacheFileExists)
{
std::ifstream cacheFile( moduleCacheFileName.string( ) );
std::istreambuf_iterator<char> cacheFileBegin( cacheFile );
std::istreambuf_iterator<char> cacheFileEnd( nullptr );
// the cache is the same, so we don't need to write the source files
if (utils::RangeEqual(
moduleFileCache.begin( ), moduleFileCache.end( ),
cacheFileBegin, cacheFileEnd
))
{
return;
}
}
// update the cache
utils::WriteText(
moduleCacheFileName.string( ),
moduleFileCache
);
// module source file
{
auto sourceTemplate = LoadTemplate( kTemplateModuleSource );
if (!sourceTemplate.isValid( ))
{
std::stringstream error;
error << "Unable to compile module source template." << std::endl;
error << sourceTemplate.errorMessage( );
throw std::exception( error.str( ).c_str( ) );
}
TemplateData sourceData { TemplateData::Type::Object };
addGlobalTemplateData( sourceData );
sourceData[ "moduleFile" ] = moduleFilesData;
COMPILE_TYPE_TEMPLATES( sourceData, "external", m_externals );
fs::path sourcePath( m_options.outputModuleSource );
fs::create_directory( sourcePath.parent_path( ) );
utils::WriteText(
sourcePath.string( ),
sourceTemplate.render( sourceData )
);
}
}
