Loading cancellation (#12)

Author: ExternPointer

include/ifcpp/Geometry/GeometryGenerator.h

@@ -111,7 +111,7 @@ class GeometryGenerator {
         this->m_parameters->m_angleFactor = ifcModel->getUnitConverter()->getAngleInRadiantFactor();
     }
 
-    std::vector<TEntity> GenerateGeometry( const std::function<void(double)>& onProgressChanged ) {
+    std::vector<TEntity> GenerateGeometry( const std::function<void(double)>& onProgressChanged, const std::atomic<bool>& isCancellationRequested = false ) {
         this->ResetCaches();
         std::vector<TEntity> entities;
 
@@ -128,13 +128,22 @@ class GeometryGenerator {
 
 #ifdef ENABLE_OPENMP
         Mutex entitiesPtrMutex;
-#pragma omp parallel default( none ) shared( entitiesPtrMutex, ifcEntitiesCount, ifcEntitiesPtr, entitiesPtr, onProgressChanged, processedCount )
+#pragma omp parallel default( none ) shared( entitiesPtrMutex, ifcEntitiesCount, ifcEntitiesPtr, entitiesPtr, onProgressChanged, processedCount, isCancellationRequested )
         {
             std::vector<TEntity> entitiesPerThread;
             entitiesPerThread.reserve( 1000 );
 #pragma omp for schedule( dynamic, 1000 )
 #endif
             for( int i = 0; i < ifcEntitiesCount; i++ ) {
+#ifdef ENABLE_OPENMP
+                if( isCancellationRequested ) {
+                    continue;
+                }
+#else
+            if( isCancellationRequested ) {
+                return {};
+            }
+#endif
                 if( !(++processedCount % 100000) ) {
                     auto progress = (double)processedCount / (double)ifcEntitiesCount;
                     if( progress < 1 ) {
@@ -166,6 +175,9 @@ class GeometryGenerator {
             }
         }
 #endif
+        if( isCancellationRequested ) {
+            return {};
+        }
         onProgressChanged( 1 );
         return entities;
     }

include/ifcpp/Model/AttributeObject.h

@@ -26,7 +26,7 @@ class AttributeObjectVector : public BuildingObject
 {
 public:
 	AttributeObjectVector() = default;
-	AttributeObjectVector( std::vector<shared_ptr<BuildingObject> >& vec ){ m_vec = vec; }
+	AttributeObjectVector( const std::vector<shared_ptr<BuildingObject> >& vec ) : m_vec( vec ) {}
 	virtual ~AttributeObjectVector()= default;
 	uint32_t classID() const override { return 3667068888; }
 	void getStepParameter( std::stringstream& /*stream*/, bool /*is_select_type = false*/ ) const override {}

include/ifcpp/Model/StatusCallback.h

@@ -109,5 +109,5 @@ class IFCQUERY_EXPORT StatusCallback {
 protected:
     std::function<void( const shared_ptr<Message>& )> m_messageCallback;
     std::function<bool()> m_isCancellationRequested;
-    StatusCallback* m_redirectTarget;
+    StatusCallback* m_redirectTarget = nullptr;
 };

include/ifcpp/ModelLoader.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <atomic>
+
 #include "ifcpp/Geometry/CAdapter.h"
 #include "ifcpp/Model/BuildingModel.h"
 #include "ifcpp/Reader/ReaderSTEP.h"
@@ -8,22 +10,29 @@
 namespace ifcpp {
 
 template<CAdapter TAdapter>
-std::vector<typename TAdapter::TEntity> LoadModel( const std::string& filePath, const std::shared_ptr<Parameters>& parameters, const std::function<void(double)>& onProgressChanged ) {
+std::vector<typename TAdapter::TEntity> LoadModel( const std::string& filePath, const std::shared_ptr<Parameters>& parameters,
+                                                   const std::function<void( double )>& onProgressChanged, const std::atomic<bool>& isCancellationRequest = false ) {
 
-    auto readerMessageCallback = [onProgressChanged]( const std::shared_ptr<StatusCallback::Message>& message ) {
+    auto readerMessageCallback = [ onProgressChanged ]( const std::shared_ptr<StatusCallback::Message>& message ) {
         if( message->m_type == StatusCallback::PROGRESS_CHANGED ) {
             onProgressChanged( message->m_progress * 0.5 );
         }
     };
 
-    auto geometryGeneratorProgressChangedCallback = [onProgressChanged]( double progress ) {
-        onProgressChanged( 0.5 + progress * 0.5 );
+    auto readerIsCancellationRequested = [ &isCancellationRequest ] () {
+        return (bool)isCancellationRequest;
     };
 
+    auto geometryGeneratorProgressChangedCallback = [ onProgressChanged ]( double progress ) { onProgressChanged( 0.5 + progress * 0.5 ); };
+
     auto ifcModel = std::make_shared<BuildingModel>();
     auto reader = std::make_shared<ReaderSTEP>();
     reader->SetMessageCallBack( readerMessageCallback );
+    reader->SetIsCancellationRequestedMethod( readerIsCancellationRequested );
     reader->loadModelFromFile( filePath, ifcModel );
+    if( isCancellationRequest ) {
+        return {};
+    }
     auto adapter = std::make_shared<TAdapter>();
     auto styleConverter = std::make_shared<ifcpp::StyleConverter>();
     auto geomUtils = std::make_shared<ifcpp::GeomUtils<typename TAdapter::TVector>>( parameters );
@@ -40,7 +49,7 @@ std::vector<typename TAdapter::TEntity> LoadModel( const std::string& filePath,
         std::make_shared<ifcpp::GeometryGenerator<TAdapter>>( ifcModel, adapter, curveConverter, extruder, geometryConverter, geomUtils, primitivesConverter,
                                                               profileConverter, solidConverter, splineConverter, styleConverter, parameters );
 
-    return geometryGenerator->GenerateGeometry( geometryGeneratorProgressChangedCallback );
+    return geometryGenerator->GenerateGeometry( geometryGeneratorProgressChangedCallback, isCancellationRequest );
 }
 
 }