comparison framework/Document.cpp @ 636:e2715204feaa fix-static-analysis

Use nullptr throughout

 //#define DEBUG_DOCUMENT 1
 
 //!!! still need to handle command history, documentRestored/documentModified
 
 Document::Document() :
-    m_mainModel(0),
+    m_mainModel(nullptr),
     m_autoAlignment(false),
     m_align(new Align()),
     m_isIncomplete(false)
 {
     connect(this,

     if (m_mainModel) {
         m_mainModel->aboutToDelete();
         emit modelAboutToBeDeleted(m_mainModel);
     }
 
-    emit mainModelChanged(0);
+    emit mainModelChanged(nullptr);
     delete m_mainModel;
 }
 
 Layer *
 Document::createLayer(LayerFactory::LayerType type)
 {
     Layer *newLayer = LayerFactory::getInstance()->createLayer(type);
-    if (!newLayer) return 0;
+    if (!newLayer) return nullptr;
 
     newLayer->setObjectName(getUniqueLayerName(newLayer->objectName()));
 
     m_layers.insert(newLayer);
 

 
 Layer *
 Document::createMainModelLayer(LayerFactory::LayerType type)
 {
     Layer *newLayer = createLayer(type);
-    if (!newLayer) return 0;
+    if (!newLayer) return nullptr;
     setModel(newLayer, m_mainModel);
     return newLayer;
 }
 
 Layer *

     LayerFactory::LayerTypeSet types =
         LayerFactory::getInstance()->getValidLayerTypes(model);
 
     if (types.empty()) {
         cerr << "WARNING: Document::importLayer: no valid display layer for model" << endl;
-        return 0;
+        return nullptr;
     }
 
     //!!! for now, just use the first suitable layer type
     LayerFactory::LayerType type = *types.begin();
 
     Layer *newLayer = LayerFactory::getInstance()->createLayer(type);
-    if (!newLayer) return 0;
+    if (!newLayer) return nullptr;
 
     newLayer->setObjectName(getUniqueLayerName(newLayer->objectName()));
 
     addImportedModel(model);
     setModel(newLayer, model);

 }
 
 Layer *
 Document::createEmptyLayer(LayerFactory::LayerType type)
 {
-    if (!m_mainModel) return 0;
+    if (!m_mainModel) return nullptr;
 
     Model *newModel =
         LayerFactory::getInstance()->createEmptyModel(type, m_mainModel);
-    if (!newModel) return 0;
+    if (!newModel) return nullptr;
 
     Layer *newLayer = createLayer(type);
     if (!newLayer) {
         delete newModel;
-        return 0;
+        return nullptr;
     }
 
     addImportedModel(newModel);
     setModel(newLayer, newModel);
 

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

                              const ModelTransformer::Input &input)
 {
     Transforms transforms;
     transforms.push_back(transform);
     vector<Layer *> layers = createDerivedLayers(transforms, input);
-    if (layers.empty()) return 0;
+    if (layers.empty()) return nullptr;
     else return layers[0];
 }
 
 vector<Layer *>
 Document::createDerivedLayers(const Transforms &transforms,
                               const ModelTransformer::Input &input)
 {
     QString message;
-    vector<Model *> newModels = addDerivedModels(transforms, input, message, 0);
+    vector<Model *> newModels = addDerivedModels(transforms, input, message, nullptr);
 
     if (newModels.empty()) {
         //!!! This identifier may be wrong!
         emit modelGenerationFailed(transforms[0].getIdentifier(), message);
         return vector<Layer *>();

                   << endl;
         return;
     }
 
     ModelRecord rec;
-    rec.source = 0;
+    rec.source = nullptr;
     rec.channel = 0;
     rec.refcount = 0;
     rec.additional = false;
 
     m_models[model] = rec;

                   << endl;
         return;
     }
 
     ModelRecord rec;
-    rec.source = 0;
+    rec.source = nullptr;
     rec.channel = 0;
     rec.refcount = 0;
     rec.additional = true;
 
     m_models[model] = rec;

         }
     }
 
     Transforms tt;
     tt.push_back(transform);
-    vector<Model *> mm = addDerivedModels(tt, input, message, 0);
-    if (mm.empty()) return 0;
+    vector<Model *> mm = addDerivedModels(tt, input, message, nullptr);
+    if (mm.empty()) return nullptr;
     else return mm[0];
 }
 
 vector<Model *>
 Document::addDerivedModels(const Transforms &transforms,

 }
 
 void
 Document::releaseModel(Model *model) // Will _not_ release main model!
 {
-    if (model == 0) {
+    if (model == nullptr) {
         return;
     }
 
     if (model == m_mainModel) {
         return;

         int sourceCount = 0;
 
         for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {
             if (i->second.source == model) {
                 ++sourceCount;
-                i->second.source = 0;
+                i->second.source = nullptr;
             }
         }
 
         if (sourceCount > 0) {
             SVDEBUG << "Document::releaseModel: Deleting model "

         // 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
         SVDEBUG << "Document::alignModel(" << model << "): is main model, setting appropriately" << endl;
-        rm->setAlignment(new AlignmentModel(model, model, 0, 0));
+        rm->setAlignment(new AlignmentModel(model, model, nullptr, nullptr));
         return;
     }
 
     if (!m_align->alignModel(m_mainModel, rm)) {
         cerr << "Alignment failed: " << m_align->getError() << endl;