void IfcPPReaderSTEP::readEntityArguments( const IfcPPModel::IfcPPSchemaVersion& ifc_version,
const std::vector<std::pair<std::string, shared_ptr<IfcPPEntity> > >& vec_entities,
const boost::unordered_map<int,shared_ptr<IfcPPEntity> >& map_entities )
{
// second pass, now read arguments
// every object can be initialized independently in parallel
const int num_objects = (int)vec_entities.size();
std::stringstream err;
// set progress
double progress = 0.3;
progressValueCallback( progress, "parse" );
double last_progress = 0.3;
const boost::unordered_map<int,shared_ptr<IfcPPEntity> >* map_entities_ptr = &map_entities;
const std::vector<std::pair<std::string, shared_ptr<IfcPPEntity> > >* vec_entities_ptr = &vec_entities;
#ifdef IFCPP_OPENMP
#pragma omp parallel firstprivate(num_objects) shared(map_entities_ptr,vec_entities_ptr)
#endif
{
const boost::unordered_map<int,shared_ptr<IfcPPEntity> > &map_entities_ptr_local = *map_entities_ptr;
#ifdef IFCPP_OPENMP
#pragma omp for schedule(dynamic, 100)
#endif
for( int i=0; i<num_objects; ++i )
{
const std::pair<std::string, shared_ptr<IfcPPEntity> >& entity_read_object = (*vec_entities_ptr)[i];
const shared_ptr<IfcPPEntity> entity = entity_read_object.second;
if( !entity )
{
continue;
}
const std::string& argument_str = entity_read_object.first;
std::vector<std::string> arguments;
std::vector<std::wstring> arguments_w;
tokenizeEntityArguments( argument_str, arguments );
// character decoding:
decodeArgumentStrings( arguments, arguments_w );
if( ifc_version.m_ifc_file_schema_enum != IfcPPModel::IFC4 )
{
if( ifc_version.m_ifc_file_schema_enum != IfcPPModel::IFC_VERSION_UNDEFINED && ifc_version.m_ifc_file_schema_enum != IfcPPModel::IFC_VERSION_UNKNOWN )
{
IfcPPEntityEnum entity_enum = entity->m_entity_enum;
applyBackwardCompatibility( ifc_version, entity_enum, arguments_w );
}
}
try
{
entity->readStepArguments( arguments_w, map_entities_ptr_local );
}
catch( std::exception& e )
{
#ifdef IFCPP_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_id << "=" << entity->className() << ": " << e.what();
}
catch( std::exception* e )
{
#ifdef IFCPP_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_id << "=" << entity->className() << ": " << e->what();
}
catch(...)
{
#ifdef IFCPP_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_id << "=" << entity->className() << " readStepData: error occurred" << std::endl;
}
if( i%10 == 0 )
{
progress = 0.3 + 0.6*double(i)/double(num_objects);
if( progress - last_progress > 0.03 )
{
#ifdef IFCPP_OPENMP
if( omp_get_thread_num() == 0 )
#endif
{
progressValueCallback( progress, "parse" );
last_progress = progress;
}
}
}
}
} // implicic barrier
if( err.tellp() > 0 )
{
messageCallback( err.str().c_str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ );
}
}
void ReaderSTEP::readEntityArguments( const BuildingModel::SchemaVersion& ifc_version,
const std::vector<std::pair<std::string, shared_ptr<BuildingEntity> > >& vec_entities, const std::map<int,shared_ptr<BuildingEntity> >& map_entities )
{
// second pass, now read arguments
// every object can be initialized independently in parallel
const int num_objects = static_cast<int>(vec_entities.size());
std::stringstream err;
// set progress
double progress = 0.3;
progressValueCallback( progress, "parse" );
double last_progress = 0.3;
const std::map<int,shared_ptr<BuildingEntity> >* map_entities_ptr = &map_entities;
const std::vector<std::pair<std::string, shared_ptr<BuildingEntity> > >* vec_entities_ptr = &vec_entities;
bool canceled = isCanceled();
#ifdef ENABLE_OPENMP
#pragma omp parallel firstprivate(num_objects) shared(map_entities_ptr,vec_entities_ptr)
#endif
{
const std::map<int,shared_ptr<BuildingEntity> > &map_entities_ptr_local = *map_entities_ptr;
#ifdef ENABLE_OPENMP
#pragma omp for schedule(dynamic, 100)
#endif
for( int i=0; i<num_objects; ++i )
{
if ( canceled )
{
continue;
}
const std::pair<std::string, shared_ptr<BuildingEntity> >& entity_read_object = (*vec_entities_ptr)[i];
const shared_ptr<BuildingEntity> entity = entity_read_object.second;
if( !entity )
{
continue;
}
const std::string& argument_str = entity_read_object.first;
std::vector<std::string> arguments;
std::vector<std::wstring> arguments_w;
tokenizeEntityArguments( argument_str, arguments );
// character decoding:
decodeArgumentStrings( arguments, arguments_w );
if( ifc_version.m_ifc_file_schema_enum != BuildingModel::IFC4 )
{
size_t num_expected_arguments = entity->getNumAttributes();
if( num_expected_arguments != arguments_w.size() )
{
while( arguments_w.size() > num_expected_arguments ) { arguments_w.pop_back(); }
while( arguments_w.size() < num_expected_arguments ) { arguments_w.emplace_back( L"$" ); }
}
}
if( std::string( entity->className() ).compare( "IfcColourRGB" ) == 0 )
{
if( arguments_w.size() < 4 )
{
arguments_w.insert( arguments_w.begin(), L"$" );
}
}
try
{
entity->readStepArguments( arguments_w, map_entities_ptr_local );
}
catch( std::exception& e )
{
#ifdef ENABLE_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_entity_id << "=" << entity->className() << ": " << e.what();
}
catch( std::exception* e )
{
#ifdef ENABLE_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_entity_id << "=" << entity->className() << ": " << e->what();
}
catch(...)
{
#ifdef ENABLE_OPENMP
#pragma omp critical
#endif
err << "#" << entity->m_entity_id << "=" << entity->className() << " readStepData: error occurred" << std::endl;
}
if( i%10 == 0 )
{
progress = 0.3 + 0.6*double(i)/double(num_objects);
if( progress - last_progress > 0.03 )
{
#ifdef ENABLE_OPENMP
if( omp_get_thread_num() == 0 )
#endif
{
progressValueCallback( progress, "parse" );
last_progress = progress;
if ( isCanceled() )
{
canceledCallback();
#ifdef ENABLE_OPENMP
canceled = true;
#pragma omp flush(canceled)
#else
break; // If we're not using OpenMP, we can safely break the loop
#endif
}
}
}
}
}
} // implicic barrier
if( err.tellp() > 0 )
{
messageCallback( err.str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ );
}
}
