comparison framework/Document.cpp @ 233:8aace2d9f1c2

Seems to be a bad idea to use plain DEBUG symbol on OS/X (system wants it)

     std::cerr << "\n\nDocument::~Document: about to clear command history" << std::endl;
 #endif
     CommandHistory::getInstance()->clear();
     
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::~Document: about to delete layers" << endl;
+    SVDEBUG << "Document::~Document: about to delete layers" << endl;
 #endif
     while (!m_layers.empty()) {
 	deleteLayer(*m_layers.begin(), true);
     }
 
     if (!m_models.empty()) {
-	DEBUG << "Document::~Document: WARNING: " 
+	SVDEBUG << "Document::~Document: WARNING: " 
 		  << m_models.size() << " model(s) still remain -- "
 		  << "should have been garbage collected when deleting layers"
 		  << endl;
 	while (!m_models.empty()) {
             Model *model = m_models.begin()->first;
 	    if (model == m_mainModel) {
 		// just in case!
-		DEBUG << "Document::~Document: WARNING: Main model is also"
+		SVDEBUG << "Document::~Document: WARNING: Main model is also"
 			  << " in models list!" << endl;
 	    } else if (model) {
                 model->aboutToDelete();
 		emit modelAboutToBeDeleted(model);
 		delete model;

 	    m_models.erase(m_models.begin());
 	}
     }
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::~Document: About to get rid of main model"
+    SVDEBUG << "Document::~Document: About to get rid of main model"
 	      << endl;
 #endif
     if (m_mainModel) {
         m_mainModel->aboutToDelete();
         emit modelAboutToBeDeleted(m_mainModel);

     newLayer->setObjectName(getUniqueLayerName(newLayer->objectName()));
 
     m_layers.insert(newLayer);
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::createLayer: Added layer of type " << type
+    SVDEBUG << "Document::createLayer: Added layer of type " << type
               << ", now have " << m_layers.size() << " layers" << endl;
 #endif
 
     emit layerAdded(newLayer);
 

     setChannel(newLayer, -1);
 
     m_layers.insert(newLayer);
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::createImportedLayer: Added layer of type " << type
+    SVDEBUG << "Document::createImportedLayer: Added layer of type " << type
               << ", now have " << m_layers.size() << " layers" << endl;
 #endif
 
     emit layerAdded(newLayer);
     return newLayer;

     // model, or delete the layer for each layer that is currently
     // using one of these.  Carry out this replacement before we
     // delete any of the models.
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::setMainModel: Have "
+    SVDEBUG << "Document::setMainModel: Have "
               << m_layers.size() << " layers" << endl;
     std::cerr << "Models now: ";
     for (ModelMap::const_iterator i = m_models.begin(); i != m_models.end(); ++i) {
         std::cerr << i->first << " ";
     } 

 
 	Layer *layer = *i;
 	Model *model = layer->getModel();
 
 #ifdef DEBUG_DOCUMENT
-        DEBUG << "Document::setMainModel: inspecting model "
+        SVDEBUG << "Document::setMainModel: inspecting model "
                   << (model ? model->objectName(): "(null)") << " in layer "
                   << layer->objectName() << endl;
 #endif
 
 	if (model == oldMainModel) {

                     emit modelRegenerationWarning(layer->objectName(),
                                                   transformId,
                                                   message);
                 }
 #ifdef DEBUG_DOCUMENT
-                DEBUG << "Replacing model " << model << " (type "
+                SVDEBUG << "Replacing model " << model << " (type "
                           << typeid(*model).name() << ") with model "
                           << replacementModel << " (type "
                           << typeid(*replacementModel).name() << ") in layer "
                           << layer << " (name " << layer->objectName() << ")"
                           << endl;

     for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
 
         Model *m = i->first;
 
 #ifdef DEBUG_DOCUMENT
-        DEBUG << "considering alignment for model " << m << " (name \""
+        SVDEBUG << "considering alignment for model " << m << " (name \""
                   << m->objectName() << "\")" << endl;
 #endif
 
         if (m_autoAlignment) {
 

 		  << std::endl;
 	return;
     }
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::addDerivedModel: source is " << input.getModel() << " \"" << input.getModel()->objectName() << "\"" << endl;
+    SVDEBUG << "Document::addDerivedModel: source is " << input.getModel() << " \"" << input.getModel()->objectName() << "\"" << endl;
 #endif
 
     ModelRecord rec;
     rec.source = input.getModel();
     rec.channel = input.getChannel();

     outputModelToAdd->setSourceModel(input.getModel());
 
     m_models[outputModelToAdd] = rec;
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::addDerivedModel: Added model " << outputModelToAdd << endl;
+    SVDEBUG << "Document::addDerivedModel: Added model " << outputModelToAdd << endl;
     std::cerr << "Models now: ";
     for (ModelMap::const_iterator i = m_models.begin(); i != m_models.end(); ++i) {
         std::cerr << i->first << " ";
     } 
     std::cerr << std::endl;

     rec.refcount = 0;
 
     m_models[model] = rec;
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::addImportedModel: Added model " << model << endl;
+    SVDEBUG << "Document::addImportedModel: Added model " << model << endl;
     std::cerr << "Models now: ";
     for (ModelMap::const_iterator i = m_models.begin(); i != m_models.end(); ++i) {
         std::cerr << i->first << " ";
     } 
     std::cerr << std::endl;

 		i->second.source = 0;
 	    }
 	}
 
 	if (sourceCount > 0) {
-	    DEBUG << "Document::releaseModel: Deleting model "
+	    SVDEBUG << "Document::releaseModel: Deleting model "
 		      << model << " even though it is source for "
 		      << sourceCount << " other derived model(s) -- resetting "
 		      << "their source fields appropriately" << endl;
 	}
 
         model->aboutToDelete();
 	emit modelAboutToBeDeleted(model);
 	m_models.erase(model);
 
 #ifdef DEBUG_DOCUMENT
-        DEBUG << "Document::releaseModel: Deleted model " << model << endl;
+        SVDEBUG << "Document::releaseModel: Deleted model " << model << endl;
         std::cerr << "Models now: ";
         for (ModelMap::const_iterator i = m_models.begin(); i != m_models.end(); ++i) {
             std::cerr << i->first << " ";
         } 
         std::cerr << std::endl;

 	    return;
 	}
     }
 
     if (m_layers.find(layer) == m_layers.end()) {
-	DEBUG << "Document::deleteLayer: Layer "
+	SVDEBUG << "Document::deleteLayer: Layer "
                   << layer << " (" << typeid(layer).name() <<
                   ") does not exist, or has already been deleted "
 		  << "(this may not be as serious as it sounds)" << endl;
 	return;
     }
 
     m_layers.erase(layer);
 
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::deleteLayer: Removing, now have "
+    SVDEBUG << "Document::deleteLayer: Removing, now have "
               << m_layers.size() << " layers" << endl;
 #endif
 
     releaseModel(layer->getModel());
     emit layerRemoved(layer);

     }
 
     Model *previousModel = layer->getModel();
 
     if (previousModel == model) {
-        DEBUG << "NOTE: Document::setModel: Layer " << layer << " (\""
+        SVDEBUG << "NOTE: Document::setModel: Layer " << layer << " (\""
                   << layer->objectName()                  << "\") is already set to model "
                   << model << " (\""
                   << (model ? model->objectName(): "(null)")
                   << "\")" << endl;
         return;

 Document::addLayerToView(View *view, Layer *layer)
 {
     Model *model = layer->getModel();
     if (!model) {
 #ifdef DEBUG_DOCUMENT
-	DEBUG << "Document::addLayerToView: Layer (\""
+	SVDEBUG << "Document::addLayerToView: Layer (\""
                   << layer->objectName()                  << "\") with no model being added to view: "
                   << "normally you want to set the model first" << endl;
 #endif
     } else {
 	if (model != m_mainModel &&

     RangeSummarisableTimeValueModel *rm = 
         dynamic_cast<RangeSummarisableTimeValueModel *>(model);
     if (!rm) return;
 
     if (rm->getAlignmentReference() == m_mainModel) {
-        DEBUG << "Document::alignModel: model " << rm << " is already aligned to main model " << m_mainModel << endl;
+        SVDEBUG << "Document::alignModel: model " << rm << " is already aligned to main model " << m_mainModel << endl;
         return;
     }
     
     if (model == m_mainModel) {
         // The reference has an empty alignment to itself.  This makes
         // it possible to distinguish between the reference and any
         // unaligned model just by looking at the model itself,
         // without also knowing what the main model is
-        DEBUG << "Document::alignModel(" << model << "): is main model, setting appropriately" << endl;
+        SVDEBUG << "Document::alignModel(" << model << "): is main model, setting appropriately" << endl;
         rm->setAlignment(new AlignmentModel(model, model, 0, 0));
         return;
     }
 
     // This involves creating three new models:

         (id, aggregateModel->getSampleRate());
 
     transform.setStepSize(transform.getBlockSize()/2);
     transform.setParameter("serialise", 1);
 
-    DEBUG << "Document::alignModel: Alignment transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << endl;
+    SVDEBUG << "Document::alignModel: Alignment transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << endl;
 
     ModelTransformerFactory *mtf = ModelTransformerFactory::getInstance();
 
     QString message;
     Model *transformOutput = mtf->transform(transform, aggregate, message);

 }
 
 Document::AddLayerCommand::~AddLayerCommand()
 {
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::AddLayerCommand::~AddLayerCommand" << endl;
+    SVDEBUG << "Document::AddLayerCommand::~AddLayerCommand" << endl;
 #endif
     if (!m_added) {
 	m_d->deleteLayer(m_layer);
     }
 }
 
 QString
 Document::AddLayerCommand::getName() const
 {
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::AddLayerCommand::getName(): Name is "
+    SVDEBUG << "Document::AddLayerCommand::getName(): Name is "
               << m_name << endl;
 #endif
     return m_name;
 }
 

 }
 
 Document::RemoveLayerCommand::~RemoveLayerCommand()
 {
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::RemoveLayerCommand::~RemoveLayerCommand" << endl;
+    SVDEBUG << "Document::RemoveLayerCommand::~RemoveLayerCommand" << endl;
 #endif
     if (!m_added) {
 	m_d->deleteLayer(m_layer);
     }
 }
 
 QString
 Document::RemoveLayerCommand::getName() const
 {
 #ifdef DEBUG_DOCUMENT
-    DEBUG << "Document::RemoveLayerCommand::getName(): Name is "
+    SVDEBUG << "Document::RemoveLayerCommand::getName(): Name is "
               << m_name << endl;
 #endif
     return m_name;
 }