void IfcPPReaderSTEP::readStepLines( const std::vector<std::string>& step_lines, std::vector<std::pair<std::string, shared_ptr<IfcPPEntity> > >& target_entity_vec )
{
std::set<std::string> unkown_entities;
std::stringstream err_unknown_entity;
double progress = 0.2;
double last_progress = 0.2;
const int num_lines = (int)step_lines.size();
target_entity_vec.resize( num_lines );
std::vector<std::pair<std::string, shared_ptr<IfcPPEntity> > >* target_vec_ptr = &target_entity_vec;
std::set<std::string>* unkown_entities_ptr = &unkown_entities;
const std::vector<std::string>* step_lines_ptr = &step_lines;
#ifdef IFCPP_OPENMP
#pragma omp parallel firstprivate(num_lines) shared(target_vec_ptr,unkown_entities_ptr,step_lines_ptr)
{
// time for reading a step line does not differ much, so schedule many per thread
#pragma omp for schedule(dynamic,100)
#endif
for( int i = 0; i<num_lines; ++i )
{
const std::string& step_line = (*step_lines_ptr)[i];
std::pair<std::string, shared_ptr<IfcPPEntity> >& entity_read_obj = (*target_vec_ptr)[i];;
// read lines: #1234=IFCOBJECTNAME(...,...,(...,...),...)
try
{
readSingleStepLine( step_line, entity_read_obj );
}
catch(UnknownEntityException& e)
{
std::string unknown_keyword = e.m_keyword;
std::string step_line = step_lines[i];
applyBackwardCompatibility( unknown_keyword, step_line );
try
{
readSingleStepLine( step_line, entity_read_obj );
}
catch( UnknownEntityException& )
{
if( unkown_entities.find( unknown_keyword ) == unkown_entities.end() )
{
#ifdef IFCPP_OPENMP
#pragma omp critical
#endif
{
unkown_entities.insert( unknown_keyword );
err_unknown_entity << "unknown IFC entity: " << unknown_keyword << std::endl;
}
}
}
}
if( i%10 == 0)
{
progress = 0.2 + 0.1*double(i)/double(num_lines);
if( progress - last_progress > 0.03 )
{
#ifdef IFCPP_OPENMP
if( omp_get_thread_num() == 0 )
#endif
{
progressValueCallback( progress, "parse" );
last_progress = progress;
}
}
}
}
#ifdef IFCPP_OPENMP
}
#endif
if( err_unknown_entity.tellp() > 0 )
{
throw UnknownEntityException( err_unknown_entity.str() );
}
}
void IfcPPReaderSTEP::readSingleStepLine( const std::string& line, std::pair<std::string, shared_ptr<IfcPPEntity> >& target_read_object )
{
if( line.size() < 1 )
{
return;
}
char* stream_pos = (char*)line.c_str();
if( *stream_pos != '#' )
{
return;
}
// need at least one integer here
++stream_pos;
if( *stream_pos == '\0' )
{
return;
}
if( !isdigit( *stream_pos ) )
{
return;
}
char* begin_id = stream_pos;
// proceed until end of integer
++stream_pos;
while( *stream_pos != '\0' )
{
if( isdigit( *stream_pos ) )
{
++stream_pos;
}
else
{
break;
}
}
const int entity_id = atoi( std::string( begin_id, stream_pos - begin_id ).c_str() );
// skip whitespace
while( isspace( *stream_pos ) ) { ++stream_pos; }
// next char after whitespace needs to be an "="
if( *stream_pos != '=' )
{
// print error
return;
}
++stream_pos;
// skip whitespaces
while( isspace( *stream_pos ) ) { ++stream_pos; }
// extract keyword
const char* keyword_begin = stream_pos;
while( isalnum( *stream_pos ) ) { ++stream_pos; }
std::string keyword( keyword_begin, stream_pos - keyword_begin );
std::transform( keyword.begin(), keyword.end(), keyword.begin(), toupper );
// proceed to '('
if( *stream_pos != '(' )
{
while( *stream_pos != '\0' )
{
if( *stream_pos == '(' )
{
break;
}
++stream_pos;
}
}
if( keyword.size() == 0 )
{
std::stringstream strs;
strs << "Could not read STEP line: " << line.c_str();
messageCallback( strs.str().c_str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ );
return;
}
std::map<std::string,IfcPPEntityEnum>::iterator it_entity_enum = map_string2entity_enum.find( keyword );
if( it_entity_enum == map_string2entity_enum.end() )
{
throw UnknownEntityException( keyword );
}
else
{
IfcPPEntityEnum entity_enum = it_entity_enum->second;
shared_ptr<IfcPPEntity> obj( createIfcPPEntity( entity_enum ) );
if( obj )
{
obj->m_id = entity_id;
obj->m_entity_enum = entity_enum;
target_read_object.second = obj;
size_t sub_length = line.size() - ( stream_pos - line.c_str() );
std::string entity_arg( stream_pos, sub_length );
target_read_object.first.assign( entity_arg.begin(), entity_arg.end() );
}
else
{
std::stringstream strs;
strs << "Could not create object of type " << keyword << ", entity id " << entity_id;
messageCallback( strs.str().c_str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ );
}
}
}
void ReaderSTEP::readSingleStepLine( const std::string& line, std::pair<std::string, shared_ptr<BuildingEntity> >& target_read_object )
{
if( line.empty() )
{
return;
}
char* stream_pos = const_cast<char*>(line.c_str());
if( *stream_pos != '#' )
{
return;
}
// need at least one integer here
++stream_pos;
if( *stream_pos == '\0' )
{
return;
}
if( !isdigit( *stream_pos ) )
{
return;
}
char* begin_id = stream_pos;
// proceed until end of integer
++stream_pos;
while( *stream_pos != '\0' )
{
if( isdigit( *stream_pos ) )
{
++stream_pos;
}
else
{
break;
}
}
const int entity_id = atoi( std::string( begin_id, stream_pos - begin_id ).c_str() );
// skip whitespace
while( isspace( *stream_pos ) ) { ++stream_pos; }
// next char after whitespace needs to be an "="
if( *stream_pos != '=' )
{
// print error
return;
}
++stream_pos;
// skip whitespaces
while( isspace( *stream_pos ) ) { ++stream_pos; }
// extract keyword
const char* entity_name_begin = stream_pos;
while( isalnum( *stream_pos ) ) { ++stream_pos; }
std::string entity_name_upper( entity_name_begin, stream_pos - entity_name_begin );
std::transform( entity_name_upper.begin(), entity_name_upper.end(), entity_name_upper.begin(), toupper );
// proceed to '('
if( *stream_pos != '(' )
{
while( *stream_pos != '\0' )
{
if( *stream_pos == '(' )
{
break;
}
++stream_pos;
}
}
if( entity_name_upper.empty() )
{
std::stringstream strs;
strs << "Could not read STEP line: " << line.c_str();
messageCallback( strs.str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ );
return;
}
shared_ptr<BuildingEntity> obj( EntityFactory::createEntityObject( entity_name_upper ) );
if( obj )
{
obj->m_entity_id = entity_id;
target_read_object.second = obj;
size_t sub_length = line.size() - (stream_pos - line.c_str());
std::string entity_arg( stream_pos, sub_length );
target_read_object.first.assign( entity_arg.begin(), entity_arg.end() );
}
else
{
throw UnknownEntityException( entity_name_upper );
}
}
