comparison framework/Document.cpp @ 229:8c13e8219903 debug-output

Convert many cerrs to DEBUGs

     std::cerr << "\n\nDocument::~Document: about to clear command history" << std::endl;
 #endif
     CommandHistory::getInstance()->clear();
     
 #ifdef DEBUG_DOCUMENT
-    std::cerr << "Document::~Document: about to delete layers" << std::endl;
+    DEBUG << "Document::~Document: about to delete layers" << endl;
 #endif
     while (!m_layers.empty()) {
 	deleteLayer(*m_layers.begin(), true);
     }
 
     if (!m_models.empty()) {
-	std::cerr << "Document::~Document: WARNING: " 
+	DEBUG << "Document::~Document: WARNING: " 
 		  << m_models.size() << " model(s) still remain -- "
 		  << "should have been garbage collected when deleting layers"
-		  << std::endl;
+		  << endl;
 	while (!m_models.empty()) {
             Model *model = m_models.begin()->first;
 	    if (model == m_mainModel) {
 		// just in case!
-		std::cerr << "Document::~Document: WARNING: Main model is also"
-			  << " in models list!" << std::endl;
+		DEBUG << "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
-    std::cerr << "Document::~Document: About to get rid of main model"
-	      << std::endl;
+    DEBUG << "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
-    std::cerr << "Document::createLayer: Added layer of type " << type
-              << ", now have " << m_layers.size() << " layers" << std::endl;
+    DEBUG << "Document::createLayer: Added layer of type " << type
+              << ", now have " << m_layers.size() << " layers" << endl;
 #endif
 
     emit layerAdded(newLayer);
 
     return newLayer;

     setChannel(newLayer, -1);
 
     m_layers.insert(newLayer);
 
 #ifdef DEBUG_DOCUMENT
-    std::cerr << "Document::createImportedLayer: Added layer of type " << type
-              << ", now have " << m_layers.size() << " layers" << std::endl;
+    DEBUG << "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
-    std::cerr << "Document::setMainModel: Have "
-              << m_layers.size() << " layers" << std::endl;
+    DEBUG << "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 << " ";
     } 
     std::cerr << std::endl;

 
 	Layer *layer = *i;
 	Model *model = layer->getModel();
 
 #ifdef DEBUG_DOCUMENT
-        std::cerr << "Document::setMainModel: inspecting model "
-                  << (model ? model->objectName().toStdString() : "(null)") << " in layer "
-                  << layer->objectName() << std::endl;
+        DEBUG << "Document::setMainModel: inspecting model "
+                  << (model ? model->objectName(): "(null)") << " in layer "
+                  << layer->objectName() << endl;
 #endif
 
 	if (model == oldMainModel) {
 #ifdef DEBUG_DOCUMENT
             std::cerr << "... it uses the old main model, replacing" << std::endl;

                     emit modelRegenerationWarning(layer->objectName(),
                                                   transformId,
                                                   message);
                 }
 #ifdef DEBUG_DOCUMENT
-                std::cerr << "Replacing model " << model << " (type "
+                DEBUG << "Replacing model " << model << " (type "
                           << typeid(*model).name() << ") with model "
                           << replacementModel << " (type "
                           << typeid(*replacementModel).name() << ") in layer "
                           << layer << " (name " << layer->objectName() << ")"
-                          << std::endl;
+                          << endl;
 #endif
                 RangeSummarisableTimeValueModel *rm =
                     dynamic_cast<RangeSummarisableTimeValueModel *>(replacementModel);
 #ifdef DEBUG_DOCUMENT
                 if (rm) {

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

 		  << std::endl;
 	return;
     }
 
 #ifdef DEBUG_DOCUMENT
-    std::cerr << "Document::addDerivedModel: source is " << input.getModel() << " \"" << input.getModel()->objectName() << "\"" << std::endl;
+    DEBUG << "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
-    std::cerr << "Document::addDerivedModel: Added model " << outputModelToAdd << std::endl;
+    DEBUG << "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
-    std::cerr << "Document::addImportedModel: Added model " << model << std::endl;
+    DEBUG << "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) {
-	    std::cerr << "Document::releaseModel: Deleting model "
+	    DEBUG << "Document::releaseModel: Deleting model "
 		      << model << " even though it is source for "
 		      << sourceCount << " other derived model(s) -- resetting "
-		      << "their source fields appropriately" << std::endl;
+		      << "their source fields appropriately" << endl;
 	}
 
         model->aboutToDelete();
 	emit modelAboutToBeDeleted(model);
 	m_models.erase(model);
 
 #ifdef DEBUG_DOCUMENT
-        std::cerr << "Document::releaseModel: Deleted model " << model << std::endl;
+        DEBUG << "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()) {
-	std::cerr << "Document::deleteLayer: Layer "
+	DEBUG << "Document::deleteLayer: Layer "
                   << layer << " (" << typeid(layer).name() <<
                   ") does not exist, or has already been deleted "
-		  << "(this may not be as serious as it sounds)" << std::endl;
+		  << "(this may not be as serious as it sounds)" << endl;
 	return;
     }
 
     m_layers.erase(layer);
 
 #ifdef DEBUG_DOCUMENT
-    std::cerr << "Document::deleteLayer: Removing, now have "
-              << m_layers.size() << " layers" << std::endl;
+    DEBUG << "Document::deleteLayer: Removing, now have "
+              << m_layers.size() << " layers" << endl;
 #endif
 
     releaseModel(layer->getModel());
     emit layerRemoved(layer);
     emit layerAboutToBeDeleted(layer);

     }
 
     Model *previousModel = layer->getModel();
 
     if (previousModel == model) {
-        std::cerr << "NOTE: Document::setModel: Layer " << layer << " (\""
-                  << layer->objectName().toStdString()
-                  << "\") is already set to model "
+        DEBUG << "NOTE: Document::setModel: Layer " << layer << " (\""
+                  << layer->objectName()                  << "\") is already set to model "
                   << model << " (\""
-                  << (model ? model->objectName().toStdString() : "(null)")
-                  << "\")" << std::endl;
+                  << (model ? model->objectName(): "(null)")
+                  << "\")" << endl;
         return;
     }
 
     if (model && model != m_mainModel) {
 	m_models[model].refcount ++;

 Document::addLayerToView(View *view, Layer *layer)
 {
     Model *model = layer->getModel();
     if (!model) {
 #ifdef DEBUG_DOCUMENT
-	std::cerr << "Document::addLayerToView: Layer (\""
-                  << layer->objectName().toStdString()
-                  << "\") with no model being added to view: "
-                  << "normally you want to set the model first" << std::endl;
+	DEBUG << "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 &&
 	    m_models.find(model) == m_models.end()) {
 	    std::cerr << "ERROR: Document::addLayerToView: Layer " << layer

     RangeSummarisableTimeValueModel *rm = 
         dynamic_cast<RangeSummarisableTimeValueModel *>(model);
     if (!rm) return;
 
     if (rm->getAlignmentReference() == m_mainModel) {
-        std::cerr << "Document::alignModel: model " << rm << " is already aligned to main model " << m_mainModel << std::endl;
+        DEBUG << "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
-        std::cerr << "Document::alignModel(" << model << "): is main model, setting appropriately" << std::endl;
+        DEBUG << "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);
 
-    std::cerr << "Document::alignModel: Alignment transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << std::endl;
+    DEBUG << "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
-    std::cerr << "Document::AddLayerCommand::~AddLayerCommand" << std::endl;
+    DEBUG << "Document::AddLayerCommand::~AddLayerCommand" << endl;
 #endif
     if (!m_added) {
 	m_d->deleteLayer(m_layer);
     }
 }
 
 QString
 Document::AddLayerCommand::getName() const
 {
 #ifdef DEBUG_DOCUMENT
-    std::cerr << "Document::AddLayerCommand::getName(): Name is "
-              << m_name << std::endl;
+    DEBUG << "Document::AddLayerCommand::getName(): Name is "
+              << m_name << endl;
 #endif
     return m_name;
 }
 
 void

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