comparison framework/Document.cpp @ 766:cf4e0f3c2406

Profiling points

             this, SIGNAL(alignmentFailed(ModelId, QString)));
 }
 
 Document::~Document()
 {
+    Profiler profiler("Document::~Document");
+    
     //!!! Document should really own the command history.  atm we
     //still refer to it in various places that don't have access to
     //the document, be nice to fix that
 
 #ifdef DEBUG_DOCUMENT

 }
 
 Layer *
 Document::createLayer(LayerFactory::LayerType type)
 {
+    Profiler profiler("Document::createLayer");
+    
     Layer *newLayer = LayerFactory::getInstance()->createLayer(type);
     if (!newLayer) return nullptr;
 
     newLayer->setObjectName(getUniqueLayerName(newLayer->objectName()));
 

 }
 
 Layer *
 Document::createMainModelLayer(LayerFactory::LayerType type)
 {
+    Profiler profiler("Document::createMainModelLayer");
+    
     Layer *newLayer = createLayer(type);
     if (!newLayer) return nullptr;
     setModel(newLayer, m_mainModel);
     return newLayer;
 }
 
 Layer *
 Document::createImportedLayer(ModelId modelId)
 {
+    Profiler profiler("Document::createImportedLayer");
+    
     LayerFactory::LayerTypeSet types =
         LayerFactory::getInstance()->getValidLayerTypes(modelId);
 
     if (types.empty()) {
         SVCERR << "WARNING: Document::importLayer: no valid display layer for model" << endl;

 }
 
 Layer *
 Document::createEmptyLayer(LayerFactory::LayerType type)
 {
+    Profiler profiler("Document::createEmptyLayer");
+    
     if (m_mainModel.isNone()) return nullptr;
 
     auto newModel =
         LayerFactory::getInstance()->createEmptyModel(type, m_mainModel);
     if (!newModel) return nullptr;

 
 Layer *
 Document::createDerivedLayer(LayerFactory::LayerType type,
                              TransformId transform)
 {
+    Profiler profiler("Document::createDerivedLayer (type)");
+    
     Layer *newLayer = createLayer(type);
     if (!newLayer) return nullptr;
 
     newLayer->setObjectName(getUniqueLayerName
                             (TransformFactory::getInstance()->

 
 Layer *
 Document::createDerivedLayer(const Transform &transform,
                              const ModelTransformer::Input &input)
 {
+    Profiler profiler("Document::createDerivedLayer (transform)");
+    
     Transforms transforms;
     transforms.push_back(transform);
     vector<Layer *> layers = createDerivedLayers(transforms, input);
     if (layers.empty()) return nullptr;
     else return layers[0];

 
 vector<Layer *>
 Document::createDerivedLayers(const Transforms &transforms,
                               const ModelTransformer::Input &input)
 {
+    Profiler profiler("Document::createDerivedLayers");
+    
     QString message;
     vector<ModelId> newModels =
         addDerivedModels(transforms, input, message, nullptr);
 
     if (newModels.empty()) {

 Document::LayerCreationAsyncHandle
 Document::createDerivedLayersAsync(const Transforms &transforms,
                                    const ModelTransformer::Input &input,
                                    LayerCreationHandler *handler)
 {
+    Profiler profiler("Document::createDerivedLayersAsync");
+    
     QString message;
 
     AdditionalModelConverter *amc = new AdditionalModelConverter(this, handler);
     
     vector<ModelId> newModels = addDerivedModels

 
 vector<Layer *>
 Document::createLayersForDerivedModels(vector<ModelId> newModels, 
                                        QStringList names)
 {
+    Profiler profiler("Document::createLayersForDerivedModels");
+    
     vector<Layer *> layers;
     
     for (int i = 0; in_range_for(newModels, i); ++i) {
 
         ModelId newModelId = newModels[i];

 }
 
 void
 Document::setMainModel(ModelId modelId)
 {
+    Profiler profiler("Document::setMainModel");
+    
     ModelId oldMainModel = m_mainModel;
     m_mainModel = modelId;
     
     emit modelAdded(m_mainModel);
     

 void
 Document::addAlreadyDerivedModel(const Transform &transform,
                                  const ModelTransformer::Input &input,
                                  ModelId outputModelToAdd)
 {
+    Profiler profiler("Document::addAlreadyDerivedModel");
+    
     if (m_models.find(outputModelToAdd) != m_models.end()) {
         SVCERR << "WARNING: Document::addAlreadyDerivedModel: Model already added"
                << endl;
         return;
     }

 }
 
 void
 Document::addNonDerivedModel(ModelId modelId)
 {
+    Profiler profiler("Document::addNonDerivedModel");
+    
     if (ModelById::isa<AggregateWaveModel>(modelId)) {
 #ifdef DEBUG_DOCUMENT
         SVCERR << "Document::addNonDerivedModel: Model " << modelId << " is an aggregate model, adding it to aggregates" << endl;
 #endif
         m_aggregateModels.insert(modelId);

 }
 
 void
 Document::addAdditionalModel(ModelId modelId)
 {
+    Profiler profiler("Document::addAdditionalModel");
+    
     if (m_models.find(modelId) != m_models.end()) {
         SVCERR << "WARNING: Document::addAdditionalModel: Model already added"
                << endl;
         return;
     }

 ModelId
 Document::addDerivedModel(const Transform &transform,
                           const ModelTransformer::Input &input,
                           QString &message)
 {
+    Profiler profiler("Document::addDerivedModel");
+    
     for (auto &rec : m_models) {
         if (rec.second.transform == transform &&
             rec.second.source == input.getModel() && 
             rec.second.channel == input.getChannel()) {
             SVDEBUG << "derived model taken from map " << endl;

 Document::addDerivedModels(const Transforms &transforms,
                            const ModelTransformer::Input &input,
                            QString &message,
                            AdditionalModelConverter *amc)
 {
+    Profiler profiler("Document::addDerivedModels");
+    
     vector<ModelId> mm = 
         ModelTransformerFactory::getInstance()->transformMultiple
         (transforms, input, message, amc);
 
     for (int j = 0; in_range_for(mm, j); ++j) {

 }
 
 void
 Document::releaseModel(ModelId modelId)
 {
+    Profiler profiler("Document::releaseModel");
+    
     // This is called when a layer has been deleted or has replaced
     // its model, in order to reclaim storage for the old model. It
     // could be a no-op without making any functional difference, as
     // all the models stored in the ById pool are released when the
     // document is deleted. But models can sometimes be large, so if

 }
 
 void
 Document::deleteLayer(Layer *layer, bool force)
 {
+    Profiler profiler("Document::deleteLayer");
+    
     if (m_layerViewMap.find(layer) != m_layerViewMap.end() &&
         m_layerViewMap[layer].size() > 0) {
 
         if (force) {
 

 }
 
 void
 Document::setModel(Layer *layer, ModelId modelId)
 {
+    Profiler profiler("Document::setModel");
+    
     if (!modelId.isNone() && 
         modelId != m_mainModel &&
         m_models.find(modelId) == m_models.end()) {
         SVCERR << "ERROR: Document::setModel: Layer " << layer
                << " (\"" << layer->objectName()