Rename several child() and children() functions

ApplicationLibCode/Application/RiaCompletionTypeCalculationScheduler.cpp

@@ -56,7 +56,7 @@ RiaCompletionTypeCalculationScheduler* RiaCompletionTypeCalculationScheduler::in
 void RiaCompletionTypeCalculationScheduler::scheduleRecalculateCompletionTypeAndRedrawAllViews()
 {
     std::vector<RimEclipseCase*> eclipseCases =
-        RimProject::current()->activeOilField()->analysisModels->cases().childObjects();
+        RimProject::current()->activeOilField()->analysisModels->cases().children();
 
     scheduleRecalculateCompletionTypeAndRedrawAllViews( eclipseCases );
 }
@@ -94,7 +94,7 @@ void RiaCompletionTypeCalculationScheduler::scheduleRecalculateCompletionTypeAnd
 void RiaCompletionTypeCalculationScheduler::clearCompletionTypeResultsInAllCases()
 {
     std::vector<RimEclipseCase*> eclipseCases =
-        RimProject::current()->activeOilField()->analysisModels->cases().childObjects();
+        RimProject::current()->activeOilField()->analysisModels->cases().children();
 
     clearCompletionTypeResults( eclipseCases );
 }

ApplicationLibCode/Application/Tools/RiaProjectModifier.cpp

@@ -169,7 +169,7 @@ void RiaProjectModifier::replaceSourceCases( RimProject* project )
                     if ( groupIdToReplace == caseGroup->groupId() )
                     {
                         RimCaseCollection* caseCollection = caseGroup->caseCollection;
-                        caseCollection->reservoirs.deleteAllChildObjects();
+                        caseCollection->reservoirs.deleteChildren();
 
                         for ( QString fileName : item.second )
                         {

ApplicationLibCode/Commands/EclipseCommands/RicEclipseShowOnlyFaultFeature.cpp

@@ -77,7 +77,7 @@ void RicEclipseShowOnlyFaultFeature::onActionTriggered( bool isChecked )
     if ( !rimFault->parentField() ) return;
 
     std::vector<caf::PdmObjectHandle*> children;
-    rimFault->parentField()->childObjects( &children );
+    rimFault->parentField()->children( &children );
 
     for ( auto& child : children )
     {

ApplicationLibCode/Commands/ExportCommands/RicAdvancedSnapshotExportFeature.cpp

@@ -147,7 +147,7 @@ void RicAdvancedSnapshotExportFeature::exportMultipleSnapshots( const QString& f
 
                 exportViewVariations( copyOfEclipseView, msd, folder );
 
-                eclCase->reservoirViews().removeChildObject( copyOfEclipseView );
+                eclCase->reservoirViews().removeChild( copyOfEclipseView );
 
                 delete copyOfEclipseView;
             }
@@ -172,7 +172,7 @@ void RicAdvancedSnapshotExportFeature::exportMultipleSnapshots( const QString& f
 
                 exportViewVariations( copyOfGeoMechView, msd, folder );
 
-                geomCase->geoMechViews().removeChildObject( copyOfGeoMechView );
+                geomCase->geoMechViews().removeChild( copyOfGeoMechView );
 
                 delete copyOfGeoMechView;
             }
@@ -210,7 +210,7 @@ void RicAdvancedSnapshotExportFeature::exportViewVariations( Rim3dView*
             exportViewVariationsToFolder( copyOfView, msd, folder );
         }
 
-        eclCase->reservoirViews().removeChildObject( copyOfView );
+        eclCase->reservoirViews().removeChild( copyOfView );
 
         delete copyOfView;
     }

ApplicationLibCode/Commands/ExportCommands/RicExportToLasFileResampleUi.cpp

@@ -84,7 +84,7 @@ RicExportToLasFileResampleUi::RicExportToLasFileResampleUi( void )
 //--------------------------------------------------------------------------------------------------
 RicExportToLasFileResampleUi::~RicExportToLasFileResampleUi()
 {
-    m_tvdrkbOffsets.deleteAllChildObjects();
+    m_tvdrkbOffsets.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/FractureCommands/RicCreateMultipleFracturesUi.cpp

@@ -127,7 +127,7 @@ void RiuCreateMultipleFractionsUi::setValues( RimEclipseCase* eclipseCase,
 void RiuCreateMultipleFractionsUi::resetValues()
 {
     m_sourceCase = nullptr;
-    m_options.deleteAllChildObjects();
+    m_options.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -135,7 +135,7 @@ void RiuCreateMultipleFractionsUi::resetValues()
 //--------------------------------------------------------------------------------------------------
 std::vector<RicCreateMultipleFracturesOptionItemUi*> RiuCreateMultipleFractionsUi::options() const
 {
-    return m_options.childObjects();
+    return m_options.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -160,7 +160,7 @@ void RiuCreateMultipleFractionsUi::insertOptionItem( RicCreateMultipleFracturesO
 //--------------------------------------------------------------------------------------------------
 void RiuCreateMultipleFractionsUi::deleteOptionItem( RicCreateMultipleFracturesOptionItemUi* optionsItem )
 {
-    m_options.removeChildObject( optionsItem );
+    m_options.removeChild( optionsItem );
     delete optionsItem;
 }
 
@@ -169,7 +169,7 @@ void RiuCreateMultipleFractionsUi::deleteOptionItem( RicCreateMultipleFracturesO
 //--------------------------------------------------------------------------------------------------
 void RiuCreateMultipleFractionsUi::clearOptions()
 {
-    m_options.deleteAllChildObjects();
+    m_options.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/RicCloseCaseFeature.cpp

@@ -152,7 +152,7 @@ void RicCloseCaseFeature::deleteEclipseCase( RimEclipseCase* eclipseCase )
             RimIdenticalGridCaseGroup* caseGroup = caseCollection->parentCaseGroup();
             CVF_ASSERT( caseGroup );
 
-            caseGroup->statisticsCaseCollection()->reservoirs.removeChildObject( eclipseCase );
+            caseGroup->statisticsCaseCollection()->reservoirs.removeChild( eclipseCase );
             caseGroup->updateConnectedEditors();
         }
         else
@@ -165,7 +165,7 @@ void RicCloseCaseFeature::deleteEclipseCase( RimEclipseCase* eclipseCase )
                 if ( caseGroup->caseCollection()->reservoirs.size() == 1 )
                 {
                     std::vector<caf::PdmObjectHandle*> children;
-                    caseGroup->statisticsCaseCollection()->reservoirs.childObjects( &children );
+                    caseGroup->statisticsCaseCollection()->reservoirs.children( &children );
 
                     for ( size_t i = children.size(); i-- > 0; )
                     {
@@ -213,7 +213,7 @@ void RicCloseCaseFeature::deleteEclipseCase( RimEclipseCase* eclipseCase )
 
         if ( cases.empty() )
         {
-            project->multiSnapshotDefinitions.deleteAllChildObjects();
+            project->multiSnapshotDefinitions.deleteChildren();
         }
         else
         {

ApplicationLibCode/Commands/RicDeleteItemExec.cpp

@@ -52,7 +52,7 @@ void RicDeleteItemExec::redo()
     if ( listField )
     {
         std::vector<caf::PdmObjectHandle*> children;
-        listField->childObjects( &children );
+        listField->children( &children );
 
         caf::PdmObjectHandle* obj = children[m_commandData.m_indexToObject];
         caf::SelectionManager::instance()->removeObjectFromAllSelections( obj );

ApplicationLibCode/Commands/RicDeleteItemFeature.cpp

@@ -80,7 +80,7 @@ void RicDeleteItemFeature::onActionTriggered( bool isChecked )
         int indexAfter = -1;
 
         std::vector<caf::PdmObjectHandle*> childObjects;
-        childArrayFieldHandle->childObjects( &childObjects );
+        childArrayFieldHandle->children( &childObjects );
 
         for ( size_t i = 0; i < childObjects.size(); i++ )
         {

ApplicationLibCode/Commands/RicElasticPropertiesImportTools.cpp

@@ -166,7 +166,7 @@ std::vector<QString> RicElasticPropertiesImportTools::getFormationNames()
     RimOilField* oilField = project->activeOilField();
 
     RimFormationNamesCollection* formationNamesCollection = oilField->formationNamesCollection();
-    for ( RimFormationNames* formationNames : formationNamesCollection->formationNamesList().childObjects() )
+    for ( RimFormationNames* formationNames : formationNamesCollection->formationNamesList().children() )
     {
         if ( formationNames && formationNames->formationNamesData() )
         {

ApplicationLibCode/Commands/SsiHubImportCommands/RimOilFieldEntry.cpp

@@ -53,7 +53,7 @@ RimOilFieldEntry::RimOilFieldEntry()
 //--------------------------------------------------------------------------------------------------
 RimOilFieldEntry::~RimOilFieldEntry()
 {
-    wells.deleteAllChildObjects();
+    wells.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/SsiHubImportCommands/RimOilRegionEntry.cpp

@@ -41,7 +41,7 @@ RimOilRegionEntry::RimOilRegionEntry()
 //--------------------------------------------------------------------------------------------------
 RimOilRegionEntry::~RimOilRegionEntry()
 {
-    fields.deleteAllChildObjects();
+    fields.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/SsiHubImportCommands/RimWellPathImport.cpp

@@ -99,7 +99,7 @@ void RimWellPathImport::updateRegions( const QStringList& regionStrings,
 
             for ( size_t i = 0; i < fieldsToRemove.size(); i++ )
             {
-                this->regions[regionIdx]->fields.removeChildObject( fieldsToRemove[i] );
+                this->regions[regionIdx]->fields.removeChild( fieldsToRemove[i] );
 
                 delete fieldsToRemove[i];
             }
@@ -108,7 +108,7 @@ void RimWellPathImport::updateRegions( const QStringList& regionStrings,
 
     for ( size_t i = 0; i < regionsToRemove.size(); i++ )
     {
-        this->regions.removeChildObject( regionsToRemove[i] );
+        this->regions.removeChild( regionsToRemove[i] );
 
         delete regionsToRemove[i];
     }
@@ -218,7 +218,7 @@ void RimWellPathImport::defineObjectEditorAttribute( QString uiConfigName, caf::
 //--------------------------------------------------------------------------------------------------
 RimWellPathImport::~RimWellPathImport()
 {
-    regions.deleteAllChildObjects();
+    regions.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Commands/SsiHubImportCommands/RiuWellImportWizard.cpp

@@ -728,7 +728,7 @@ void RiuWellImportWizard::parseWellsResponse( RimOilFieldEntry* oilFieldEntry )
 
     for ( size_t i = 0; i < wellsToRemove.size(); i++ )
     {
-        oilFieldEntry->wells.removeChildObject( wellsToRemove[i] );
+        oilFieldEntry->wells.removeChild( wellsToRemove[i] );
 
         delete wellsToRemove[i];
     }
@@ -902,7 +902,7 @@ void WellSelectionPage::buildWellTreeView()
     }
 
     // Delete all temporary pdm object groups
-    m_regionsWithVisibleWells->objects.deleteAllChildObjects();
+    m_regionsWithVisibleWells->objects.deleteChildren();
 
     for ( size_t rIdx = 0; rIdx < m_wellPathImportObject->regions.size(); rIdx++ )
     {
@@ -982,7 +982,7 @@ void WellSelectionPage::selectedWellPathEntries( std::vector<DownloadEntity>& do
     for ( size_t i = 0; i < childFields.size(); i++ )
     {
         std::vector<caf::PdmObjectHandle*> childObjects;
-        childFields[i]->childObjects( &childObjects );
+        childFields[i]->children( &childObjects );
 
         for ( size_t j = 0; j < childObjects.size(); j++ )
         {
@@ -1117,7 +1117,7 @@ void WellSummaryPage::initializePage()
 //--------------------------------------------------------------------------------------------------
 void WellSummaryPage::updateSummaryPage()
 {
-    m_objectGroup->objects.clear();
+    m_objectGroup->objects.clearWithoutDelete();
 
     m_textEdit->setText( "Summary of imported wells\n\n" );
 

ApplicationLibCode/Commands/ToggleCommands/RicToggleItemsOnOthersOffFeature.cpp

@@ -122,7 +122,7 @@ std::vector<caf::PdmObjectHandle*> RicToggleItemsOnOthersOffFeature::childObject
     std::vector<caf::PdmObjectHandle*> children;
     if ( parent )
     {
-        parent->childObjects( &children );
+        parent->children( &children );
     }
     return children;
 }

ApplicationLibCode/Commands/ViewLink/RicDeleteAllLinkedViewsFeature.cpp

@@ -42,7 +42,7 @@ public:
         {
             // Remove the view linker object from the view linker collection
             // viewLinkerCollection->viewLinker is a PdmChildField containing one RimViewLinker child object
-            proj->viewLinkerCollection->viewLinker.removeChildObject( viewLinker );
+            proj->viewLinkerCollection->viewLinker.removeChild( viewLinker );
 
             viewLinker->applyCellFilterCollectionByUserChoice();
 

ApplicationLibCode/Commands/ViewLink/RicUnLinkViewFeature.cpp

@@ -87,7 +87,7 @@ void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
         {
             // Remove the view linker object from the view linker collection
             // viewLinkerCollection->viewLinker is a PdmChildField containing one RimViewLinker child object
-            RimProject::current()->viewLinkerCollection->viewLinker.removeChildObject( viewLinker );
+            RimProject::current()->viewLinkerCollection->viewLinker.removeChild( viewLinker );
 
             delete viewLinker;
         }

ApplicationLibCode/FileInterface/RifEclipseInputPropertyLoader.cpp

@@ -45,7 +45,7 @@ void RifEclipseInputPropertyLoader::loadAndSyncronizeInputProperties( RimEclipse
                                                                       const std::vector<QString>& filenames,
                                                                       bool                        allowImportOfFaults )
 {
-    std::vector<RimEclipseInputProperty*> existingProperties = inputPropertyCollection->inputProperties.childObjects();
+    std::vector<RimEclipseInputProperty*> existingProperties = inputPropertyCollection->inputProperties.children();
 
     caf::ProgressInfo progInfo( static_cast<int>( filenames.size() ), "Reading Input properties" );
 

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp

@@ -206,7 +206,7 @@ RimPlotDataFilterCollection* RimAnalysisPlot::plotDataFilterCollection() const
 //--------------------------------------------------------------------------------------------------
 void RimAnalysisPlot::setCurveDefinitions( const std::vector<RiaSummaryCurveDefinition>& curveDefinitions )
 {
-    m_analysisPlotDataSelection.deleteAllChildObjects();
+    m_analysisPlotDataSelection.deleteChildren();
     for ( auto curveDef : curveDefinitions )
     {
         auto dataEntry = new RimAnalysisPlotDataEntry();
@@ -463,7 +463,7 @@ void RimAnalysisPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
         {
             std::vector<RiaSummaryCurveDefinition> summaryVectorDefinitions = dlg.curveSelection();
 
-            m_analysisPlotDataSelection.deleteAllChildObjects();
+            m_analysisPlotDataSelection.deleteChildren();
             for ( const RiaSummaryCurveDefinition& vectorDef : summaryVectorDefinitions )
             {
                 auto dataEntry = new RimAnalysisPlotDataEntry();
@@ -1794,7 +1794,7 @@ void RimAnalysisPlot::onCaseRemoved( const SignalEmitter* emitter, RimSummaryCas
     {
         if ( existingEntry->summaryCase() == summaryCase )
         {
-            m_analysisPlotDataSelection.removeChildObject( existingEntry );
+            m_analysisPlotDataSelection.removeChild( existingEntry );
             delete existingEntry;
             break;
         }

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotCollection.cpp

@@ -123,7 +123,7 @@ void RimAnalysisPlotCollection::updateSummaryNameHasChanged()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimAnalysisPlot*> RimAnalysisPlotCollection::plots() const
 {
-    return m_analysisPlots.childObjects();
+    return m_analysisPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -263,6 +263,6 @@ void RimAnalysisPlotCollection::insertPlot( RimAnalysisPlot* analysisPlot, size_
 //--------------------------------------------------------------------------------------------------
 void RimAnalysisPlotCollection::removePlot( RimAnalysisPlot* analysisPlot )
 {
-    m_analysisPlots.removeChildObject( analysisPlot );
+    m_analysisPlots.removeChild( analysisPlot );
     updateAllRequiredEditors();
 }

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterCollection.cpp

@@ -56,7 +56,7 @@ RimPlotDataFilterItem* RimPlotDataFilterCollection::addFilter()
 //--------------------------------------------------------------------------------------------------
 void RimPlotDataFilterCollection::removeFilter( RimPlotDataFilterItem* filter )
 {
-    m_filters.removeChildObject( filter );
+    m_filters.removeChild( filter );
     delete filter;
 
     filtersChanged.send();
@@ -67,7 +67,7 @@ void RimPlotDataFilterCollection::removeFilter( RimPlotDataFilterItem* filter )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPlotDataFilterItem*> RimPlotDataFilterCollection::filters() const
 {
-    return m_filters.childObjects();
+    return m_filters.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Annotations/RimAnnotationGroupCollection.cpp

@@ -95,7 +95,7 @@ void RimAnnotationGroupCollection::addAnnotation( caf::PdmObject* annotation )
 //--------------------------------------------------------------------------------------------------
 void RimAnnotationGroupCollection::removeAnnotation( caf::PdmObject* annotation )
 {
-    m_annotations.removeChildObject( annotation );
+    m_annotations.removeChild( annotation );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -103,7 +103,7 @@ void RimAnnotationGroupCollection::removeAnnotation( caf::PdmObject* annotation
 //--------------------------------------------------------------------------------------------------
 std::vector<caf::PdmObject*> RimAnnotationGroupCollection::annotations() const
 {
-    return m_annotations.childObjects();
+    return m_annotations.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp

@@ -95,7 +95,7 @@ cvf::ref<RigPolyLinesData> RimUserDefinedPolylinesAnnotation::polyLinesData()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPolylineTarget*> RimUserDefinedPolylinesAnnotation::activeTargets() const
 {
-    return m_targets.childObjects();
+    return m_targets.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -113,7 +113,7 @@ void RimUserDefinedPolylinesAnnotation::appendTarget( const cvf::Vec3d& defaultP
 {
     RimPolylineTarget* target = nullptr;
 
-    auto targets = m_targets.childObjects();
+    auto targets = m_targets.children();
     if ( targets.empty() )
     {
         target = new RimPolylineTarget();
@@ -149,7 +149,7 @@ void RimUserDefinedPolylinesAnnotation::insertTarget( const RimPolylineTarget* t
 //--------------------------------------------------------------------------------------------------
 void RimUserDefinedPolylinesAnnotation::deleteTarget( RimPolylineTarget* targetToDelete )
 {
-    m_targets.removeChildObject( targetToDelete );
+    m_targets.removeChild( targetToDelete );
     delete targetToDelete;
 }
 

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.cpp

@@ -103,7 +103,7 @@ void RimCellFilterCollection::setCase( RimCase* theCase )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimCellFilter*> RimCellFilterCollection::filters() const
 {
-    return m_cellFilters.childObjects();
+    return m_cellFilters.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -120,7 +120,7 @@ void RimCellFilterCollection::initAfterRead()
     }
     for ( auto& filter : filters )
     {
-        m_rangeFilters_OBSOLETE.removeChildObject( filter );
+        m_rangeFilters_OBSOLETE.removeChild( filter );
         m_cellFilters.push_back( filter );
     }
 
@@ -328,7 +328,7 @@ void RimCellFilterCollection::onChildDeleted( caf::PdmChildArrayFieldHandle*
 //--------------------------------------------------------------------------------------------------
 void RimCellFilterCollection::removeFilter( RimCellFilter* filter )
 {
-    m_cellFilters.removeChildObject( filter );
+    m_cellFilters.removeChild( filter );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimEclipsePropertyFilterCollection.cpp

@@ -47,7 +47,7 @@ RimEclipsePropertyFilterCollection::RimEclipsePropertyFilterCollection()
 //--------------------------------------------------------------------------------------------------
 RimEclipsePropertyFilterCollection::~RimEclipsePropertyFilterCollection()
 {
-    propertyFilters.deleteAllChildObjects();
+    propertyFilters.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimGeoMechPropertyFilterCollection.cpp

@@ -45,7 +45,7 @@ RimGeoMechPropertyFilterCollection::RimGeoMechPropertyFilterCollection()
 //--------------------------------------------------------------------------------------------------
 RimGeoMechPropertyFilterCollection::~RimGeoMechPropertyFilterCollection()
 {
-    propertyFilters.deleteAllChildObjects();
+    propertyFilters.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.cpp

@@ -257,7 +257,7 @@ QString RimPolygonFilter::fullName() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPolylineTarget*> RimPolygonFilter::activeTargets() const
 {
-    return m_targets.childObjects();
+    return m_targets.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -279,7 +279,7 @@ void RimPolygonFilter::insertTarget( const RimPolylineTarget* targetToInsertBefo
 //--------------------------------------------------------------------------------------------------
 void RimPolygonFilter::deleteTarget( RimPolylineTarget* targetToDelete )
 {
-    m_targets.removeChildObject( targetToDelete );
+    m_targets.removeChild( targetToDelete );
     delete targetToDelete;
 }
 

ApplicationLibCode/ProjectDataModel/Completions/Rim3dWellLogCurveCollection.cpp

@@ -50,7 +50,7 @@ Rim3dWellLogCurveCollection::Rim3dWellLogCurveCollection()
 //--------------------------------------------------------------------------------------------------
 Rim3dWellLogCurveCollection::~Rim3dWellLogCurveCollection()
 {
-    m_3dWellLogCurves.deleteAllChildObjects();
+    m_3dWellLogCurves.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -80,7 +80,7 @@ void Rim3dWellLogCurveCollection::add3dWellLogCurve( Rim3dWellLogCurve* curve )
 //--------------------------------------------------------------------------------------------------
 void Rim3dWellLogCurveCollection::remove3dWellLogCurve( Rim3dWellLogCurve* curve )
 {
-    m_3dWellLogCurves.removeChildObject( curve );
+    m_3dWellLogCurves.removeChild( curve );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimEnsembleFractureStatisticsCollection.cpp

@@ -46,7 +46,7 @@ void RimEnsembleFractureStatisticsCollection::addFractureGroupStatistics( RimEns
 //--------------------------------------------------------------------------------------------------
 void RimEnsembleFractureStatisticsCollection::loadAndUpdateData()
 {
-    for ( auto f : m_fractureGroupStatistics.childObjects() )
+    for ( auto f : m_fractureGroupStatistics.children() )
     {
         f->loadAndUpdateData();
     }

ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp

@@ -155,7 +155,7 @@ std::vector<RimFishbones*> RimFishbonesCollection::activeFishbonesSubs() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimFishbones*> RimFishbonesCollection::allFishbonesSubs() const
 {
-    return m_fishbones.childObjects();
+    return m_fishbones.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -228,7 +228,7 @@ double RimFishbonesCollection::endMD() const
     double endMD = m_startMD;
     if ( !m_fishbones.empty() )
     {
-        auto lastFishbone = m_fishbones.childObjects().back();
+        auto lastFishbone = m_fishbones.children().back();
         CVF_ASSERT( lastFishbone );
         endMD = lastFishbone->endMD();
     }

ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp

@@ -71,7 +71,7 @@ RimFractureTemplateCollection::RimFractureTemplateCollection()
 //--------------------------------------------------------------------------------------------------
 RimFractureTemplateCollection::~RimFractureTemplateCollection()
 {
-    m_fractureDefinitions.deleteAllChildObjects();
+    m_fractureDefinitions.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimPerforationCollection.cpp

@@ -59,7 +59,7 @@ RimPerforationCollection::RimPerforationCollection()
 //--------------------------------------------------------------------------------------------------
 RimPerforationCollection::~RimPerforationCollection()
 {
-    m_perforations.deleteAllChildObjects();
+    m_perforations.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimSimWellFractureCollection.cpp

@@ -41,7 +41,7 @@ RimSimWellFractureCollection::RimSimWellFractureCollection( void )
 //--------------------------------------------------------------------------------------------------
 RimSimWellFractureCollection::~RimSimWellFractureCollection()
 {
-    simwellFractures.deleteAllChildObjects();
+    simwellFractures.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -49,7 +49,7 @@ RimSimWellFractureCollection::~RimSimWellFractureCollection()
 //--------------------------------------------------------------------------------------------------
 void RimSimWellFractureCollection::deleteFractures()
 {
-    simwellFractures.deleteAllChildObjects();
+    simwellFractures.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplateCollection.cpp

@@ -69,7 +69,7 @@ void RimValveTemplateCollection::addValveTemplate( RimValveTemplate* valveTempla
 //--------------------------------------------------------------------------------------------------
 void RimValveTemplateCollection::removeAndDeleteValveTemplate( RimValveTemplate* valveTemplate )
 {
-    m_valveDefinitions.removeChildObject( valveTemplate );
+    m_valveDefinitions.removeChild( valveTemplate );
     delete valveTemplate;
 }
 

ApplicationLibCode/ProjectDataModel/Completions/RimWellPathFractureCollection.cpp

@@ -69,7 +69,7 @@ void RimWellPathFractureCollection::addFracture( RimWellPathFracture* fracture )
 //--------------------------------------------------------------------------------------------------
 void RimWellPathFractureCollection::deleteFractures()
 {
-    m_fractures.deleteAllChildObjects();
+    m_fractures.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -77,7 +77,7 @@ void RimWellPathFractureCollection::deleteFractures()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimWellPathFracture*> RimWellPathFractureCollection::allFractures() const
 {
-    return m_fractures.childObjects();
+    return m_fractures.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.cpp

@@ -105,7 +105,7 @@ RimAbstractCorrelationPlot::~RimAbstractCorrelationPlot()
 //--------------------------------------------------------------------------------------------------
 void RimAbstractCorrelationPlot::setCurveDefinitions( const std::vector<RiaSummaryCurveDefinition>& curveDefinitions )
 {
-    m_dataSources.deleteAllChildObjects();
+    m_dataSources.deleteChildren();
     for ( auto curveDef : curveDefinitions )
     {
         auto dataEntry = new RimAnalysisPlotDataEntry();
@@ -155,7 +155,7 @@ void RimAbstractCorrelationPlot::fieldChangedByUi( const caf::PdmFieldHandle* ch
             if ( !curveSelection.empty() )
             {
                 std::vector<RiaSummaryCurveDefinition> summaryVectorDefinitions = dlg.curveSelection();
-                m_dataSources.deleteAllChildObjects();
+                m_dataSources.deleteChildren();
                 for ( const RiaSummaryCurveDefinition& vectorDef : summaryVectorDefinitions )
                 {
                     auto plotEntry = new RimAnalysisPlotDataEntry();

ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlotCollection.cpp

@@ -193,7 +193,7 @@ void RimCorrelationPlotCollection::insertPlot( RimAbstractCorrelationPlot* plot,
 //--------------------------------------------------------------------------------------------------
 void RimCorrelationPlotCollection::removePlot( RimAbstractCorrelationPlot* plot )
 {
-    m_correlationPlots.removeChildObject( plot );
+    m_correlationPlots.removeChild( plot );
     updateAllRequiredEditors();
 }
 
@@ -202,7 +202,7 @@ void RimCorrelationPlotCollection::removePlot( RimAbstractCorrelationPlot* plot
 //--------------------------------------------------------------------------------------------------
 std::vector<RimAbstractCorrelationPlot*> RimCorrelationPlotCollection::plots() const
 {
-    return m_correlationPlots.childObjects();
+    return m_correlationPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -218,7 +218,7 @@ size_t RimCorrelationPlotCollection::plotCount() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimCorrelationReportPlot*> RimCorrelationPlotCollection::reports() const
 {
-    return m_correlationReports.childObjects();
+    return m_correlationReports.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -227,7 +227,7 @@ std::vector<RimCorrelationReportPlot*> RimCorrelationPlotCollection::reports() c
 void RimCorrelationPlotCollection::deleteAllPlots()
 {
     RimTypedPlotCollection<RimAbstractCorrelationPlot>::deleteAllPlots();
-    m_correlationReports.deleteAllChildObjects();
+    m_correlationReports.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Faults/RimFaultInViewCollection.cpp

@@ -117,7 +117,7 @@ RimFaultInViewCollection::RimFaultInViewCollection()
 //--------------------------------------------------------------------------------------------------
 RimFaultInViewCollection::~RimFaultInViewCollection()
 {
-    faults.deleteAllChildObjects();
+    faults.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -269,7 +269,7 @@ void RimFaultInViewCollection::syncronizeFaults()
         newFaults.push_back( rimFault );
     }
 
-    this->faults().clear();
+    this->faults().clearWithoutDelete();
     this->faults().insert( 0, newFaults );
 
     QString toolTip = QString( "Fault count (%1)" ).arg( newFaults.size() );

ApplicationLibCode/ProjectDataModel/Faults/RimFaultRASettings.cpp

@@ -270,7 +270,7 @@ void RimFaultRASettings::initFromPreprocSettings( RimFaultRAPreprocSettings* pre
     RifParameterXmlReader basicreader( RiaPreferencesGeoMech::current()->geomechFRADefaultBasicXML() );
     if ( !basicreader.parseFile( errorText ) ) return;
 
-    m_basicParameters.clear();
+    m_basicParameters.clearWithoutDelete();
     for ( auto group : basicreader.parameterGroups() )
     {
         m_basicParameters.push_back( group );
@@ -281,7 +281,7 @@ void RimFaultRASettings::initFromPreprocSettings( RimFaultRAPreprocSettings* pre
         RifParameterXmlReader advreader( RiaPreferencesGeoMech::current()->geomechFRADefaultAdvXML() );
         if ( !advreader.parseFile( errorText ) ) return;
 
-        m_advancedParameters.clear();
+        m_advancedParameters.clearWithoutDelete();
         for ( auto group : advreader.parameterGroups() )
         {
             m_advancedParameters.push_back( group );
@@ -406,7 +406,7 @@ std::list<RimGenericParameter*> RimFaultRASettings::basicParameters( int faultID
         retlist.push_back( p );
     }
 
-    for ( auto& group : m_basicParameters.childObjects() )
+    for ( auto& group : m_basicParameters.children() )
     {
         for ( auto& p : group->parameters() )
         {
@@ -437,7 +437,7 @@ std::list<RimGenericParameter*> RimFaultRASettings::advancedParameters( int faul
         retlist.push_back( p );
     }
 
-    for ( auto& group : m_advancedParameters.childObjects() )
+    for ( auto& group : m_advancedParameters.children() )
     {
         for ( auto& p : group->parameters() )
         {
@@ -611,13 +611,13 @@ RimGenericParameter* RimFaultRASettings::getInputParameter( QString name ) const
 {
     RimGenericParameter* retval = nullptr;
 
-    for ( auto group : m_basicParameters.childObjects() )
+    for ( auto group : m_basicParameters.children() )
     {
         retval = group->parameter( name );
         if ( retval != nullptr ) return retval;
     }
 
-    for ( auto group : m_advancedParameters.childObjects() )
+    for ( auto group : m_advancedParameters.children() )
     {
         retval = group->parameter( name );
         if ( retval != nullptr ) return retval;

ApplicationLibCode/ProjectDataModel/Flow/RimFlowPlotCollection.cpp

@@ -60,7 +60,7 @@ RimFlowPlotCollection::~RimFlowPlotCollection()
 {
     delete m_defaultWellAllocPlot();
 
-    m_storedWellAllocPlots.deleteAllChildObjects();
+    m_storedWellAllocPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -78,8 +78,8 @@ void RimFlowPlotCollection::deleteAllPlots()
     // delete m_dbgWellDistributionPlot;
     delete m_wellDistributionPlotCollection;
 
-    m_storedWellAllocPlots.deleteAllChildObjects();
+    m_storedWellAllocPlots.deleteChildren();
-    m_storedFlowCharacteristicsPlots.deleteAllChildObjects();
+    m_storedFlowCharacteristicsPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Flow/RimWellDistributionPlotCollection.cpp

@@ -99,7 +99,7 @@ RimWellDistributionPlotCollection::RimWellDistributionPlotCollection()
 RimWellDistributionPlotCollection::~RimWellDistributionPlotCollection()
 {
     removeMdiWindowFromMdiArea();
-    m_plots.deleteAllChildObjects();
+    m_plots.deleteChildren();
 
     cleanupBeforeClose();
 }
@@ -384,7 +384,7 @@ void RimWellDistributionPlotCollection::updatePlots()
 //--------------------------------------------------------------------------------------------------
 void RimWellDistributionPlotCollection::cleanupBeforeClose()
 {
-    auto plotVector = m_plots.childObjects();
+    auto plotVector = m_plots.children();
     for ( size_t tIdx = 0; tIdx < plotVector.size(); ++tIdx )
     {
         plotVector[tIdx]->detachAllCurves();

ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp

@@ -1045,7 +1045,7 @@ void RimWellPltPlot::initAfterLoad()
 //--------------------------------------------------------------------------------------------------
 void RimWellPltPlot::syncSourcesIoFieldFromGuiField()
 {
-    m_selectedSourcesForIo.clear();
+    m_selectedSourcesForIo.clearWithoutDelete();
 
     for ( const RifDataSourceForRftPlt& addr : m_selectedSources() )
     {

ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.cpp

@@ -1360,7 +1360,7 @@ void RimWellRftPlot::createEnsembleCurveSets()
 
     for ( RimWellRftEnsembleCurveSet* curveSet : curveSetsToDelete )
     {
-        m_ensembleCurveSets.removeChildObject( curveSet );
+        m_ensembleCurveSets.removeChild( curveSet );
         delete curveSet;
     }
 

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechCase.cpp

@@ -183,7 +183,7 @@ RimGeoMechCase::RimGeoMechCase( void )
 //--------------------------------------------------------------------------------------------------
 RimGeoMechCase::~RimGeoMechCase( void )
 {
-    geoMechViews.deleteAllChildObjects();
+    geoMechViews.deleteChildren();
 
     RimProject* project = RimProject::current();
     if ( project )
@@ -418,7 +418,7 @@ std::vector<Rim3dView*> RimGeoMechCase::allSpecialViews() const
 void RimGeoMechCase::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
 {
     std::vector<PdmObjectHandle*> children;
-    geoMechViews.childObjects( &children );
+    geoMechViews.children( &children );
 
     for ( auto child : children )
         uiTreeOrdering.add( child );

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapViewCollection.cpp

@@ -28,7 +28,7 @@ RimGeoMechContourMapViewCollection::~RimGeoMechContourMapViewCollection()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGeoMechContourMapView*> RimGeoMechContourMapViewCollection::views()
 {
-    return m_contourMapViews.childObjects();
+    return m_contourMapViews.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechModels.cpp

@@ -52,7 +52,7 @@ RimGeoMechModels::~RimGeoMechModels( void )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGeoMechCase*> RimGeoMechModels::cases() const
 {
-    return m_cases.childObjects();
+    return m_cases.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -68,7 +68,7 @@ void RimGeoMechModels::addCase( RimGeoMechCase* thecase )
 //--------------------------------------------------------------------------------------------------
 void RimGeoMechModels::removeCase( RimGeoMechCase* thecase )
 {
-    m_cases.removeChildObject( thecase );
+    m_cases.removeChild( thecase );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechPartCollection.cpp

@@ -69,7 +69,7 @@ void RimGeoMechPartCollection::syncWithCase( RimGeoMechCase* geoCase )
 
         if ( count != (int)m_parts.size() )
         {
-            m_parts.clear();
+            m_parts.clearWithoutDelete();
 
             for ( int i = 0; i < count; i++ )
             {
@@ -91,7 +91,7 @@ void RimGeoMechPartCollection::syncWithCase( RimGeoMechCase* geoCase )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGeoMechPart*> RimGeoMechPartCollection::parts() const
 {
-    return m_parts.childObjects();
+    return m_parts.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp

@@ -143,7 +143,7 @@ void RimGridCrossPlot::addDataSet( RimGridCrossPlotDataSet* dataSet )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGridCrossPlotDataSet*> RimGridCrossPlot::dataSets() const
 {
-    return m_crossPlotDataSets.childObjects();
+    return m_crossPlotDataSets.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -642,8 +642,8 @@ void RimGridCrossPlot::swapAxes()
                                      yAxisProperties->plotAxisType().axis() );
     yAxisProperties->setNameAndAxis( tmpName, tmpTitle, tmpAxis.axis() );
 
-    m_xAxisProperties.removeChildObject( xAxisProperties );
+    m_xAxisProperties.removeChild( xAxisProperties );
-    m_yAxisProperties.removeChildObject( yAxisProperties );
+    m_yAxisProperties.removeChild( yAxisProperties );
     m_yAxisProperties = xAxisProperties;
     m_xAxisProperties = yAxisProperties;
 

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotCollection.cpp

@@ -45,7 +45,7 @@ RimGridCrossPlotCollection::~RimGridCrossPlotCollection()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGridCrossPlot*> RimGridCrossPlotCollection::plots() const
 {
-    return m_gridCrossPlots.childObjects();
+    return m_gridCrossPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -82,6 +82,6 @@ void RimGridCrossPlotCollection::insertPlot( RimGridCrossPlot* plot, size_t inde
 //--------------------------------------------------------------------------------------------------
 void RimGridCrossPlotCollection::removePlot( RimGridCrossPlot* plot )
 {
-    m_gridCrossPlots.removeChildObject( plot );
+    m_gridCrossPlots.removeChild( plot );
     updateAllRequiredEditors();
 }

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp

@@ -372,7 +372,7 @@ RimRegularLegendConfig* RimGridCrossPlotDataSet::legendConfig() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGridCrossPlotCurve*> RimGridCrossPlotDataSet::curves() const
 {
-    return m_crossPlotCurves.childObjects();
+    return m_crossPlotCurves.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -684,7 +684,7 @@ void RimGridCrossPlotDataSet::fillCurveDataInExistingCurves( const RigEclipseCro
 void RimGridCrossPlotDataSet::destroyCurves()
 {
     detachAllCurves();
-    m_crossPlotCurves.deleteAllChildObjects();
+    m_crossPlotCurves.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -970,7 +970,7 @@ QList<caf::PdmOptionItemInfo> RimGridCrossPlotDataSet::calculateValueOptions( co
         if ( eclipseCase )
         {
             options.push_back( caf::PdmOptionItemInfo( "Disabled", nullptr ) );
-            for ( RimEclipseView* view : eclipseCase->reservoirViews.childObjects() )
+            for ( RimEclipseView* view : eclipseCase->reservoirViews.children() )
             {
                 CVF_ASSERT( view && "Really always should have a valid view pointer in ReservoirViews" );
                 options.push_back( caf::PdmOptionItemInfo( view->name(), view, false, view->uiIconProvider() ) );
@@ -1122,8 +1122,8 @@ void RimGridCrossPlotDataSet::swapAxisProperties( bool updatePlot )
     RimEclipseResultDefinition* xAxisProperties = m_xAxisProperty();
     RimEclipseResultDefinition* yAxisProperties = m_yAxisProperty();
 
-    m_xAxisProperty.removeChildObject( xAxisProperties );
+    m_xAxisProperty.removeChild( xAxisProperties );
-    m_yAxisProperty.removeChildObject( yAxisProperties );
+    m_yAxisProperty.removeChild( yAxisProperties );
     m_yAxisProperty = xAxisProperties;
     m_xAxisProperty = yAxisProperties;
 

ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp

@@ -110,7 +110,7 @@ std::vector<RimSaturationPressurePlot*>
 //--------------------------------------------------------------------------------------------------
 std::vector<RimSaturationPressurePlot*> RimSaturationPressurePlotCollection::plots() const
 {
-    return m_saturationPressurePlots.childObjects();
+    return m_saturationPressurePlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -126,7 +126,7 @@ size_t RimSaturationPressurePlotCollection::plotCount() const
 //--------------------------------------------------------------------------------------------------
 void RimSaturationPressurePlotCollection::deleteAllPlots()
 {
-    m_saturationPressurePlots.deleteAllChildObjects();
+    m_saturationPressurePlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionCollection.cpp

@@ -79,8 +79,8 @@ RimIntersectionCollection::RimIntersectionCollection()
 //--------------------------------------------------------------------------------------------------
 RimIntersectionCollection::~RimIntersectionCollection()
 {
-    m_intersections.deleteAllChildObjects();
+    m_intersections.deleteChildren();
-    m_intersectionBoxes.deleteAllChildObjects();
+    m_intersectionBoxes.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -254,7 +254,7 @@ void RimIntersectionCollection::rebuildGeometry()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimExtrudedCurveIntersection*> RimIntersectionCollection::intersections() const
 {
-    return m_intersections.childObjects();
+    return m_intersections.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -262,7 +262,7 @@ std::vector<RimExtrudedCurveIntersection*> RimIntersectionCollection::intersecti
 //--------------------------------------------------------------------------------------------------
 std::vector<RimBoxIntersection*> RimIntersectionCollection::intersectionBoxes() const
 {
-    return m_intersectionBoxes.childObjects();
+    return m_intersectionBoxes.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionResultsDefinitionCollection.cpp

@@ -61,7 +61,7 @@ bool RimIntersectionResultsDefinitionCollection::isActive() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimIntersectionResultDefinition*> RimIntersectionResultsDefinitionCollection::intersectionResultsDefinitions() const
 {
-    return m_intersectionResultsDefs.childObjects();
+    return m_intersectionResultsDefs.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Parameters/RimParameterGroup.cpp

@@ -280,7 +280,7 @@ std::vector<RimGenericParameter*> RimParameterGroup::parameters() const
 {
     std::vector<RimGenericParameter*> retParams;
 
-    for ( const auto& p : m_parameters.childObjects() )
+    for ( const auto& p : m_parameters.children() )
     {
         if ( isListParameter( p->name() ) ) continue;
         retParams.push_back( p );
@@ -288,7 +288,7 @@ std::vector<RimGenericParameter*> RimParameterGroup::parameters() const
 
     for ( const auto& list : m_lists )
     {
-        retParams.push_back( list->getAsListParameter( m_parameters.childObjects() ) );
+        retParams.push_back( list->getAsListParameter( m_parameters.children() ) );
     }
 
     return retParams;
@@ -324,7 +324,7 @@ void RimParameterGroup::setParameterValue( QString name, QString value )
 //--------------------------------------------------------------------------------------------------
 RimGenericParameter* RimParameterGroup::parameter( QString name ) const
 {
-    for ( auto& p : m_parameters.childObjects() )
+    for ( auto& p : m_parameters.children() )
     {
         if ( p->name() == name )
         {

ApplicationLibCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFolderItem.cpp

@@ -56,8 +56,8 @@ RimPlotTemplateFolderItem::~RimPlotTemplateFolderItem()
 //--------------------------------------------------------------------------------------------------
 void RimPlotTemplateFolderItem::createRootFolderItemsFromFolderPaths( const QStringList& folderPaths )
 {
-    m_fileNames.deleteAllChildObjects();
+    m_fileNames.deleteChildren();
-    m_subFolders.deleteAllChildObjects();
+    m_subFolders.deleteChildren();
 
     createSubFolderItemsFromFolderPaths( folderPaths );
 }
@@ -67,7 +67,7 @@ void RimPlotTemplateFolderItem::createRootFolderItemsFromFolderPaths( const QStr
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPlotTemplateFileItem*> RimPlotTemplateFolderItem::fileNames() const
 {
-    return m_fileNames.childObjects();
+    return m_fileNames.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -75,7 +75,7 @@ std::vector<RimPlotTemplateFileItem*> RimPlotTemplateFolderItem::fileNames() con
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPlotTemplateFolderItem*> RimPlotTemplateFolderItem::subFolders() const
 {
-    return m_subFolders.childObjects();
+    return m_subFolders.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -103,8 +103,8 @@ void RimPlotTemplateFolderItem::setFolderPath( const QString& path )
 //--------------------------------------------------------------------------------------------------
 void RimPlotTemplateFolderItem::searchForFileAndFolderNames()
 {
-    m_fileNames.deleteAllChildObjects();
+    m_fileNames.deleteChildren();
-    m_subFolders.deleteAllChildObjects();
+    m_subFolders.deleteChildren();
 
     if ( m_folderName().path().isEmpty() )
     {

ApplicationLibCode/ProjectDataModel/Rim2dIntersectionViewCollection.cpp

@@ -47,7 +47,7 @@ Rim2dIntersectionViewCollection::~Rim2dIntersectionViewCollection()
 //--------------------------------------------------------------------------------------------------
 std::vector<Rim2dIntersectionView*> Rim2dIntersectionViewCollection::views()
 {
-    return m_intersectionViews.childObjects();
+    return m_intersectionViews.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -73,7 +73,7 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
 
     // Clean up the container by removing nullptr's
 
-    m_intersectionViews.removeChildObject( nullptr );
+    m_intersectionViews.removeChild( nullptr );
 
     // Build map from intersection to view
 
@@ -84,7 +84,7 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
         intersectionToViewMap[iv->intersection()] = iv;
     }
 
-    m_intersectionViews.clear(); // Not deleting the views. The are managed by the map
+    m_intersectionViews.clearWithoutDelete(); // Not deleting the views. The are managed by the map
 
     // Insert the old views in correct order, and create new views as we go
 

ApplicationLibCode/ProjectDataModel/RimCaseCollection.cpp

@@ -41,7 +41,7 @@ RimCaseCollection::RimCaseCollection()
 //--------------------------------------------------------------------------------------------------
 RimCaseCollection::~RimCaseCollection()
 {
-    reservoirs.deleteAllChildObjects();
+    reservoirs.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimColorLegend.cpp

@@ -104,7 +104,7 @@ void RimColorLegend::appendColorLegendItem( RimColorLegendItem* colorLegendItem
 //--------------------------------------------------------------------------------------------------
 std::vector<RimColorLegendItem*> RimColorLegend::colorLegendItems() const
 {
-    return m_colorLegendItems.childObjects();
+    return m_colorLegendItems.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimColorLegendCollection.cpp

@@ -76,7 +76,7 @@ bool RimColorLegendCollection::isStandardColorLegend( RimColorLegend* legend )
 //--------------------------------------------------------------------------------------------------
 void RimColorLegendCollection::deleteCustomColorLegends()
 {
-    m_customColorLegends.deleteAllChildObjects();
+    m_customColorLegends.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -138,13 +138,13 @@ std::vector<RimColorLegend*> RimColorLegendCollection::allColorLegends() const
 {
     std::vector<RimColorLegend*> allLegends;
 
-    auto standardLegends = m_standardColorLegends.childObjects();
+    auto standardLegends = m_standardColorLegends.children();
     for ( auto l : standardLegends )
     {
         allLegends.push_back( l );
     }
 
-    auto customLegends = m_customColorLegends.childObjects();
+    auto customLegends = m_customColorLegends.children();
     for ( auto l : customLegends )
     {
         allLegends.push_back( l );

ApplicationLibCode/ProjectDataModel/RimCommandObject.cpp

@@ -265,7 +265,7 @@ void RimCommandIssueFieldChanged::childObjects( caf::PdmObject* pdmObject, std::
     size_t fIdx;
     for ( fIdx = 0; fIdx < fields.size(); ++fIdx )
     {
-        if ( fields[fIdx] ) fields[fIdx]->childObjects( &children );
+        if ( fields[fIdx] ) fields[fIdx]->children( &children );
     }
 }
 
@@ -289,7 +289,7 @@ caf::PdmObjectHandle* RimCommandIssueFieldChanged::findObjectByName( caf::PdmObj
         if ( fields[fIdx] )
         {
             std::vector<caf::PdmObjectHandle*> children;
-            fields[fIdx]->childObjects( &children );
+            fields[fIdx]->children( &children );
 
             for ( size_t cIdx = 0; cIdx < children.size(); cIdx++ )
             {

ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunction.cpp

@@ -80,7 +80,7 @@ RimCustomObjectiveFunctionWeight* RimCustomObjectiveFunction::addWeight()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimCustomObjectiveFunctionWeight*> RimCustomObjectiveFunction::weights() const
 {
-    return m_weights.childObjects();
+    return m_weights.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -350,7 +350,7 @@ RimCustomObjectiveFunctionCollection* RimCustomObjectiveFunction::parentCollecti
 //--------------------------------------------------------------------------------------------------
 RimObjectiveFunction* RimCustomObjectiveFunction::objectiveFunction( RimObjectiveFunction::FunctionType functionType ) const
 {
-    for ( auto objectiveFunc : m_objectiveFunctions.childObjects() )
+    for ( auto objectiveFunc : m_objectiveFunctions.children() )
     {
         if ( objectiveFunc->functionType() == functionType )
         {

ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunctionCollection.cpp

@@ -58,7 +58,7 @@ void RimCustomObjectiveFunctionCollection::onObjectiveFunctionChanged( RimCustom
 //--------------------------------------------------------------------------------------------------
 std::vector<RimCustomObjectiveFunction*> RimCustomObjectiveFunctionCollection::objectiveFunctions() const
 {
-    return m_objectiveFunctions.childObjects();
+    return m_objectiveFunctions.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunctionWeight.cpp

@@ -155,7 +155,7 @@ void RimCustomObjectiveFunctionWeight::fieldChangedByUi( const caf::PdmFieldHand
         RimSummaryCaseCollection* candidateEnsemble = parentCurveSet()->summaryCaseCollection();
 
         std::vector<RifEclipseSummaryAddress> candidateAddresses;
-        for ( auto address : m_objectiveValuesSummaryAddresses().childObjects() )
+        for ( auto address : m_objectiveValuesSummaryAddresses().children() )
         {
             candidateAddresses.push_back( address->address() );
         }
@@ -167,7 +167,7 @@ void RimCustomObjectiveFunctionWeight::fieldChangedByUi( const caf::PdmFieldHand
             auto curveSelection = dlg.curveSelection();
             if ( !curveSelection.empty() )
             {
-                m_objectiveValuesSummaryAddresses.clear();
+                m_objectiveValuesSummaryAddresses.clearWithoutDelete();
                 for ( auto address : curveSelection )
                 {
                     RimSummaryAddress* summaryAddress = new RimSummaryAddress();

ApplicationLibCode/ProjectDataModel/RimDepthTrackPlot.cpp

@@ -165,7 +165,7 @@ RimDepthTrackPlot::~RimDepthTrackPlot()
     delete m_nameConfig;
 
     removeMdiWindowFromMdiArea();
-    m_plots.deleteAllChildObjects();
+    m_plots.deleteChildren();
 
     cleanupBeforeClose();
 }
@@ -178,8 +178,8 @@ RimDepthTrackPlot& RimDepthTrackPlot::operator=( RimDepthTrackPlot&& rhs )
     RimPlotWindow::operator=( std::move( rhs ) );
 
     // Move all tracks
-    auto plots = rhs.m_plots.childObjects();
+    auto plots = rhs.m_plots.children();
-    rhs.m_plots.clear();
+    rhs.m_plots.clearWithoutDelete();
     for ( auto plot : plots )
     {
         m_plots.push_back( plot );
@@ -190,7 +190,7 @@ RimDepthTrackPlot& RimDepthTrackPlot::operator=( RimDepthTrackPlot&& rhs )
     // They had their own description at top level which we don't want to overwrite.
 
     auto dataSource = rhs.m_commonDataSource();
-    rhs.m_commonDataSource.removeChildObject( dataSource );
+    rhs.m_commonDataSource.removeChild( dataSource );
     m_commonDataSource        = dataSource;
     m_commonDataSourceEnabled = rhs.m_commonDataSourceEnabled;
 
@@ -270,7 +270,7 @@ std::vector<RimPlot*> RimDepthTrackPlot::plots() const
 {
     std::vector<RimPlot*> baseClassPlots;
 
-    for ( auto p : m_plots.childObjects() )
+    for ( auto p : m_plots.children() )
     {
         baseClassPlots.push_back( p );
     }
@@ -1082,7 +1082,7 @@ void RimDepthTrackPlot::removePlot( RimPlot* plot )
         {
             m_viewer->removePlot( plot->plotWidget() );
         }
-        m_plots.removeChildObject( plot );
+        m_plots.removeChild( plot );
 
         onPlotAdditionOrRemoval();
     }
@@ -1211,7 +1211,7 @@ RiuPlotAxis RimDepthTrackPlot::valueAxis() const
 //--------------------------------------------------------------------------------------------------
 void RimDepthTrackPlot::setAutoScalePropertyValuesEnabled( bool enabled )
 {
-    for ( auto plot : m_plots.childObjects() )
+    for ( auto plot : m_plots.children() )
     {
         plot->setAutoScalePropertyValuesEnabled( enabled );
     }

ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp

@@ -146,7 +146,7 @@ RimEclipseCase::RimEclipseCase()
 //--------------------------------------------------------------------------------------------------
 RimEclipseCase::~RimEclipseCase()
 {
-    reservoirViews.deleteAllChildObjects();
+    reservoirViews.deleteChildren();
 
     delete m_matrixModelResults();
     delete m_fractureModelResults();
@@ -573,7 +573,7 @@ void RimEclipseCase::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrderin
     if ( uiConfigName == "MainWindow.ProjectTree" )
     {
         std::vector<PdmObjectHandle*> children;
-        reservoirViews.childObjects( &children );
+        reservoirViews.children( &children );
 
         for ( auto child : children )
             uiTreeOrdering.add( child );
@@ -602,7 +602,7 @@ void RimEclipseCase::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrderin
 //--------------------------------------------------------------------------------------------------
 void RimEclipseCase::buildChildNodes()
 {
-    m_resultAddressCollections.deleteAllChildObjects();
+    m_resultAddressCollections.deleteChildren();
 
     std::vector<RiaDefines::ResultCatType> resultTypes = { RiaDefines::ResultCatType::STATIC_NATIVE,
                                                            RiaDefines::ResultCatType::DYNAMIC_NATIVE,

ApplicationLibCode/ProjectDataModel/RimEclipseCaseCollection.cpp

@@ -67,8 +67,8 @@ void RimEclipseCaseCollection::close()
 {
     m_gridCollection->clear();
 
-    cases.deleteAllChildObjects();
+    cases.deleteChildren();
-    caseGroups.deleteAllChildObjects();
+    caseGroups.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -109,7 +109,7 @@ void RimEclipseCaseCollection::removeCaseFromAllGroups( RimEclipseCase* reservoi
         cg->removeCase( reservoir );
     }
 
-    cases().removeChildObject( reservoir );
+    cases().removeChild( reservoir );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.cpp

@@ -81,7 +81,7 @@ RimEclipseCellColors::~RimEclipseCellColors()
 {
     CVF_ASSERT( obsoleteField_legendConfig() == nullptr );
 
-    m_legendConfigData.deleteAllChildObjects();
+    m_legendConfigData.deleteChildren();
 
     delete m_ternaryLegendConfig();
 }

ApplicationLibCode/ProjectDataModel/RimEclipseContourMapViewCollection.cpp

@@ -28,7 +28,7 @@ RimEclipseContourMapViewCollection::~RimEclipseContourMapViewCollection()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimEclipseContourMapView*> RimEclipseContourMapViewCollection::views()
 {
-    return m_contourMapViews.childObjects();
+    return m_contourMapViews.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseInputPropertyCollection.cpp

@@ -42,7 +42,7 @@ RimEclipseInputPropertyCollection::RimEclipseInputPropertyCollection()
 //--------------------------------------------------------------------------------------------------
 RimEclipseInputPropertyCollection::~RimEclipseInputPropertyCollection()
 {
-    inputProperties.deleteAllChildObjects();
+    inputProperties.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.cpp

@@ -487,8 +487,8 @@ cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel( QString mode
 //--------------------------------------------------------------------------------------------------
 RimEclipseResultCase::~RimEclipseResultCase()
 {
-    reservoirViews.deleteAllChildObjects();
+    reservoirViews.deleteChildren();
-    m_flowDiagSolutions.deleteAllChildObjects();
+    m_flowDiagSolutions.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCase.cpp

@@ -556,7 +556,7 @@ void RimEclipseStatisticsCase::fieldChangedByUi( const caf::PdmFieldHandle* chan
             RimEclipseView* reservoirView = reservoirViews()[i];
             CVF_ASSERT( reservoirView );
 
-            reservoirView->wellCollection()->wells.deleteAllChildObjects();
+            reservoirView->wellCollection()->wells.deleteChildren();
             reservoirView->updateDisplayModelForWellResults();
             reservoirView->wellCollection()->updateConnectedEditors();
 

ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCaseCollection.cpp

@@ -42,7 +42,7 @@ RimEclipseStatisticsCaseCollection::RimEclipseStatisticsCaseCollection()
 //--------------------------------------------------------------------------------------------------
 RimEclipseStatisticsCaseCollection::~RimEclipseStatisticsCaseCollection()
 {
-    cases.deleteAllChildObjects();
+    cases.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp

@@ -1627,7 +1627,7 @@ void RimEclipseView::syncronizeWellsWithResults()
             delete well;
         }
     }
-    this->wellCollection()->wells().clear();
+    this->wellCollection()->wells().clearWithoutDelete();
 
     // Set the new wells into the field.
     this->wellCollection()->wells().insert( 0, newWells );

ApplicationLibCode/ProjectDataModel/RimEnsembleFractureStatisticsPlotCollection.cpp

@@ -69,7 +69,7 @@ void RimEnsembleFractureStatisticsPlotCollection::addEnsembleFractureStatisticsP
 std::vector<RimEnsembleFractureStatisticsPlot*>
     RimEnsembleFractureStatisticsPlotCollection::ensembleFractureStatisticsPlots() const
 {
-    return m_ensembleFractureStatisticsPlots.childObjects();
+    return m_ensembleFractureStatisticsPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -77,5 +77,5 @@ std::vector<RimEnsembleFractureStatisticsPlot*>
 //--------------------------------------------------------------------------------------------------
 void RimEnsembleFractureStatisticsPlotCollection::deleteAllPlots()
 {
-    m_ensembleFractureStatisticsPlots.deleteAllChildObjects();
+    m_ensembleFractureStatisticsPlots.deleteChildren();
 }

ApplicationLibCode/ProjectDataModel/RimFormationNamesCollection.cpp

@@ -42,7 +42,7 @@ RimFormationNamesCollection::RimFormationNamesCollection()
 //--------------------------------------------------------------------------------------------------
 RimFormationNamesCollection::~RimFormationNamesCollection()
 {
-    m_formationNamesList.deleteAllChildObjects();
+    m_formationNamesList.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -109,7 +109,7 @@ std::vector<RimFormationNames*> RimFormationNamesCollection::importFiles( const
         RiaLogging::errorInMessageBox( nullptr, "Import Formation Names", totalErrorMessage );
     }
 
-    return m_formationNamesList.childObjects();
+    return m_formationNamesList.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimGridCollection.cpp

@@ -182,7 +182,7 @@ void RimGridInfoCollection::addGridInfo( RimGridInfo* gridInfo )
 //--------------------------------------------------------------------------------------------------
 void RimGridInfoCollection::clear()
 {
-    m_gridInfos.deleteAllChildObjects();
+    m_gridInfos.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -219,7 +219,7 @@ void RimGridInfoCollection::deleteGridInfo( const QString& gridName )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGridInfo*> RimGridInfoCollection::gridInfos() const
 {
-    return m_gridInfos.childObjects();
+    return m_gridInfos.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimGridStatisticsPlot.cpp

@@ -193,7 +193,7 @@ QList<caf::PdmOptionItemInfo> RimGridStatisticsPlot::calculateValueOptions( cons
         if ( eclipseCase )
         {
             options.push_back( caf::PdmOptionItemInfo( "Disabled", nullptr ) );
-            for ( RimEclipseView* view : eclipseCase->reservoirViews.childObjects() )
+            for ( RimEclipseView* view : eclipseCase->reservoirViews.children() )
             {
                 CVF_ASSERT( view && "Really always should have a valid view pointer in ReservoirViews" );
                 options.push_back( caf::PdmOptionItemInfo( view->name(), view, false, view->uiIconProvider() ) );

ApplicationLibCode/ProjectDataModel/RimGridStatisticsPlotCollection.cpp

@@ -68,7 +68,7 @@ void RimGridStatisticsPlotCollection::addGridStatisticsPlot( RimGridStatisticsPl
 //--------------------------------------------------------------------------------------------------
 std::vector<RimGridStatisticsPlot*> RimGridStatisticsPlotCollection::gridStatisticsPlots() const
 {
-    return m_gridStatisticsPlots.childObjects();
+    return m_gridStatisticsPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -76,5 +76,5 @@ std::vector<RimGridStatisticsPlot*> RimGridStatisticsPlotCollection::gridStatist
 //--------------------------------------------------------------------------------------------------
 void RimGridStatisticsPlotCollection::deleteAllPlots()
 {
-    m_gridStatisticsPlots.deleteAllChildObjects();
+    m_gridStatisticsPlots.deleteChildren();
 }

ApplicationLibCode/ProjectDataModel/RimGridView.cpp

@@ -299,7 +299,7 @@ void RimGridView::replaceCellFilterCollectionWithOverride()
 
     // Must call removeChildObject() to make sure the object has no parent
     // No parent is required when assigning a object into a field
-    m_overrideCellFilterCollection.removeChildObject( overrideRfc );
+    m_overrideCellFilterCollection.removeChild( overrideRfc );
 
     m_cellFilterCollection = overrideRfc;
 

ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp

@@ -140,7 +140,7 @@ void RimIdenticalGridCaseGroup::removeCase( RimEclipseCase* reservoir )
         return;
     }
 
-    caseCollection()->reservoirs().removeChildObject( reservoir );
+    caseCollection()->reservoirs().removeChild( reservoir );
 
     if ( caseCollection()->reservoirs().size() == 0 )
     {
@@ -244,9 +244,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
         computeUnionOfActiveCells();
     }
 
-    RigCaseCellResultsData::copyResultsMetaDataFromMainCase( rigCaseData,
+    RigCaseCellResultsData::copyResultsMetaDataFromMainCase( rigCaseData, poroModel, caseCollection->reservoirs.children() );
-                                                             poroModel,
-                                                             caseCollection->reservoirs.childObjects() );
 
     // "Load" the statistical cases
 

ApplicationLibCode/ProjectDataModel/RimMultiPlot.cpp

@@ -89,7 +89,7 @@ RimMultiPlot::~RimMultiPlot()
     m_isValid = false;
 
     removeMdiWindowFromMdiArea();
-    m_plots.deleteAllChildObjects();
+    m_plots.deleteChildren();
 
     cleanupBeforeClose();
 }
@@ -102,8 +102,8 @@ RimMultiPlot& RimMultiPlot::operator=( RimMultiPlot&& rhs )
     RimPlotWindow::operator=( std::move( rhs ) );
 
     // Move all tracks
-    std::vector<RimPlot*> plots = rhs.m_plots.childObjects();
+    std::vector<RimPlot*> plots = rhs.m_plots.children();
-    rhs.m_plots.clear();
+    rhs.m_plots.clearWithoutDelete();
     for ( RimPlot* plot : plots )
     {
         m_plots.push_back( plot );
@@ -218,7 +218,7 @@ void RimMultiPlot::removePlot( RimPlot* plot )
         {
             m_viewer->removePlot( plot->plotWidget() );
         }
-        m_plots.removeChildObject( plot );
+        m_plots.removeChild( plot );
 
         onPlotAdditionOrRemoval();
     }
@@ -235,7 +235,7 @@ void RimMultiPlot::removePlotNoUpdate( RimPlot* plot )
         {
             m_viewer->removePlotNoUpdate( plot->plotWidget() );
         }
-        m_plots.removeChildObject( plot );
+        m_plots.removeChild( plot );
     }
 }
 
@@ -295,7 +295,7 @@ void RimMultiPlot::deleteAllPlots()
         }
     }
 
-    m_plots.deleteAllChildObjects();
+    m_plots.deleteChildren();
     onPlotAdditionOrRemoval();
 }
 
@@ -320,7 +320,7 @@ size_t RimMultiPlot::plotIndex( const RimPlot* plot ) const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPlot*> RimMultiPlot::plots() const
 {
-    return m_plots.childObjects();
+    return m_plots.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimMultiPlotCollection.cpp

@@ -48,7 +48,7 @@ RimMultiPlotCollection::~RimMultiPlotCollection()
 //--------------------------------------------------------------------------------------------------
 void RimMultiPlotCollection::deleteAllPlots()
 {
-    m_multiPlots.deleteAllChildObjects();
+    m_multiPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -56,7 +56,7 @@ void RimMultiPlotCollection::deleteAllPlots()
 //--------------------------------------------------------------------------------------------------
 std::vector<RimMultiPlot*> RimMultiPlotCollection::multiPlots() const
 {
-    return m_multiPlots.childObjects();
+    return m_multiPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -72,7 +72,7 @@ void RimMultiPlotCollection::addMultiPlot( RimMultiPlot* plot )
 //--------------------------------------------------------------------------------------------------
 void RimMultiPlotCollection::loadDataAndUpdateAllPlots()
 {
-    for ( const auto& p : m_multiPlots.childObjects() )
+    for ( const auto& p : m_multiPlots.children() )
         p->loadDataAndUpdate();
 }
 

ApplicationLibCode/ProjectDataModel/RimObservedDataCollection.cpp

@@ -61,8 +61,8 @@ RimObservedDataCollection::RimObservedDataCollection()
 //--------------------------------------------------------------------------------------------------
 RimObservedDataCollection::~RimObservedDataCollection()
 {
-    m_observedDataArray.deleteAllChildObjects();
+    m_observedDataArray.deleteChildren();
-    m_observedFmuRftArray.deleteAllChildObjects();
+    m_observedFmuRftArray.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -70,7 +70,7 @@ RimObservedDataCollection::~RimObservedDataCollection()
 //--------------------------------------------------------------------------------------------------
 void RimObservedDataCollection::removeObservedSummaryData( RimObservedSummaryData* observedData )
 {
-    m_observedDataArray.removeChildObject( observedData );
+    m_observedDataArray.removeChild( observedData );
     caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
 }
 
@@ -79,7 +79,7 @@ void RimObservedDataCollection::removeObservedSummaryData( RimObservedSummaryDat
 //--------------------------------------------------------------------------------------------------
 void RimObservedDataCollection::removeObservedFmuRftData( RimObservedFmuRftData* observedFmuRftData )
 {
-    m_observedFmuRftArray.removeChildObject( observedFmuRftData );
+    m_observedFmuRftArray.removeChild( observedFmuRftData );
     caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();
 }
 
@@ -88,7 +88,7 @@ void RimObservedDataCollection::removeObservedFmuRftData( RimObservedFmuRftData*
 //--------------------------------------------------------------------------------------------------
 std::vector<RimObservedSummaryData*> RimObservedDataCollection::allObservedSummaryData() const
 {
-    return m_observedDataArray.childObjects();
+    return m_observedDataArray.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -96,7 +96,7 @@ std::vector<RimObservedSummaryData*> RimObservedDataCollection::allObservedSumma
 //--------------------------------------------------------------------------------------------------
 std::vector<RimObservedFmuRftData*> RimObservedDataCollection::allObservedFmuRftData() const
 {
-    return m_observedFmuRftArray.childObjects();
+    return m_observedFmuRftArray.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimOilField.cpp

@@ -126,7 +126,7 @@ void RimOilField::initAfterRead()
     RimFractureTemplateCollection* fractureTemplateCollection = m_fractureTemplateCollection_OBSOLETE.value();
     if ( !fractureTemplateCollection->fractureTemplates().empty() )
     {
-        m_fractureTemplateCollection_OBSOLETE.removeChildObject( fractureTemplateCollection );
+        m_fractureTemplateCollection_OBSOLETE.removeChild( fractureTemplateCollection );
         completionTemplateCollection->setFractureTemplateCollection( fractureTemplateCollection );
     }
 }

ApplicationLibCode/ProjectDataModel/RimPlotAxisProperties.cpp

@@ -409,7 +409,7 @@ bool RimPlotAxisProperties::isAxisInverted() const
 //--------------------------------------------------------------------------------------------------
 std::vector<RimPlotAxisAnnotation*> RimPlotAxisProperties::annotations() const
 {
-    return m_annotations.childObjects();
+    return m_annotations.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -425,7 +425,7 @@ void RimPlotAxisProperties::appendAnnotation( RimPlotAxisAnnotation* annotation
 //--------------------------------------------------------------------------------------------------
 void RimPlotAxisProperties::removeAllAnnotations()
 {
-    m_annotations.clear();
+    m_annotations.clearWithoutDelete();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimPltPlotCollection.cpp

@@ -50,7 +50,7 @@ RimPltPlotCollection::RimPltPlotCollection()
 //--------------------------------------------------------------------------------------------------
 RimPltPlotCollection::~RimPltPlotCollection()
 {
-    m_pltPlots.deleteAllChildObjects();
+    m_pltPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -246,7 +246,7 @@ void RimPltPlotCollection::addPlot( gsl::not_null<RimWellPltPlot*> newPlot )
 //--------------------------------------------------------------------------------------------------
 void RimPltPlotCollection::removePlot( gsl::not_null<RimWellPltPlot*> plot )
 {
-    m_pltPlots.removeChildObject( plot );
+    m_pltPlots.removeChild( plot );
     updateAllRequiredEditors();
 }
 
@@ -255,5 +255,5 @@ void RimPltPlotCollection::removePlot( gsl::not_null<RimWellPltPlot*> plot )
 //--------------------------------------------------------------------------------------------------
 void RimPltPlotCollection::deleteAllPlots()
 {
-    m_pltPlots.deleteAllChildObjects();
+    m_pltPlots.deleteChildren();
 }

ApplicationLibCode/ProjectDataModel/RimProject.cpp

@@ -249,17 +249,17 @@ void RimProject::close()
         mainPlotCollection()->deleteAllContainedObjects();
     }
 
-    oilFields.deleteAllChildObjects();
+    oilFields.deleteChildren();
     oilFields.push_back( new RimOilField );
 
-    casesObsolete.deleteAllChildObjects();
+    casesObsolete.deleteChildren();
-    caseGroupsObsolete.deleteAllChildObjects();
+    caseGroupsObsolete.deleteChildren();
 
-    wellPathImport->regions().deleteAllChildObjects();
+    wellPathImport->regions().deleteChildren();
 
-    commandObjects.deleteAllChildObjects();
+    commandObjects.deleteChildren();
 
-    multiSnapshotDefinitions.deleteAllChildObjects();
+    multiSnapshotDefinitions.deleteChildren();
 
     m_dialogData->clearProjectSpecificData();
 
@@ -314,7 +314,7 @@ void RimProject::initAfterRead()
 
     if ( movedOneRimIdenticalGridCaseGroup )
     {
-        caseGroupsObsolete.clear();
+        caseGroupsObsolete.clearWithoutDelete();
     }
 
     bool movedOneRimCase = false;
@@ -331,7 +331,7 @@ void RimProject::initAfterRead()
 
     if ( movedOneRimCase )
     {
-        casesObsolete.clear();
+        casesObsolete.clearWithoutDelete();
     }
 
     // Set project pointer to each well path
@@ -378,8 +378,8 @@ bool RimProject::writeProjectFile()
 //--------------------------------------------------------------------------------------------------
 void RimProject::setScriptDirectories( const QString& scriptDirectories )
 {
-    scriptCollection->calcScripts().deleteAllChildObjects();
+    scriptCollection->calcScripts().deleteChildren();
-    scriptCollection->subDirectories().deleteAllChildObjects();
+    scriptCollection->subDirectories().deleteChildren();
 
     QStringList pathList = scriptDirectories.split( ';' );
     foreach ( QString path, pathList )

ApplicationLibCode/ProjectDataModel/RimProject.h

@@ -261,7 +261,7 @@ void RimProject::fieldContentsByType( const caf::PdmObjectHandle* object, std::v
             }
         }
 
-        field->childObjects( &children );
+        field->children( &children );
     }
 
     for ( const auto& child : children )

ApplicationLibCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp

@@ -64,7 +64,7 @@ RimReservoirCellResultsStorage::RimReservoirCellResultsStorage()
 //--------------------------------------------------------------------------------------------------
 RimReservoirCellResultsStorage::~RimReservoirCellResultsStorage()
 {
-    m_resultCacheMetaData.deleteAllChildObjects();
+    m_resultCacheMetaData.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -77,7 +77,7 @@ RimReservoirCellResultsStorage::~RimReservoirCellResultsStorage()
 //--------------------------------------------------------------------------------------------------
 void RimReservoirCellResultsStorage::setupBeforeSave()
 {
-    m_resultCacheMetaData.deleteAllChildObjects();
+    m_resultCacheMetaData.deleteChildren();
     QString newValidCacheFileName = getValidCacheFileName();
 
     // Delete the storage file

ApplicationLibCode/ProjectDataModel/RimRftPlotCollection.cpp

@@ -50,7 +50,7 @@ RimRftPlotCollection::RimRftPlotCollection()
 //--------------------------------------------------------------------------------------------------
 RimRftPlotCollection::~RimRftPlotCollection()
 {
-    m_rftPlots.deleteAllChildObjects();
+    m_rftPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -246,7 +246,7 @@ void RimRftPlotCollection::addPlot( gsl::not_null<RimWellRftPlot*> newPlot )
 //--------------------------------------------------------------------------------------------------
 void RimRftPlotCollection::removePlot( gsl::not_null<RimWellRftPlot*> plot )
 {
-    m_rftPlots.removeChildObject( plot );
+    m_rftPlots.removeChild( plot );
     updateAllRequiredEditors();
 }
 
@@ -255,5 +255,5 @@ void RimRftPlotCollection::removePlot( gsl::not_null<RimWellRftPlot*> plot )
 //--------------------------------------------------------------------------------------------------
 void RimRftPlotCollection::deleteAllPlots()
 {
-    m_rftPlots.deleteAllChildObjects();
+    m_rftPlots.deleteChildren();
 }

ApplicationLibCode/ProjectDataModel/RimScriptCollection.cpp

@@ -53,8 +53,8 @@ RimScriptCollection::RimScriptCollection()
 //--------------------------------------------------------------------------------------------------
 RimScriptCollection::~RimScriptCollection()
 {
-    calcScripts.deleteAllChildObjects();
+    calcScripts.deleteChildren();
-    subDirectories.deleteAllChildObjects();
+    subDirectories.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -62,7 +62,7 @@ RimScriptCollection::~RimScriptCollection()
 //--------------------------------------------------------------------------------------------------
 void RimScriptCollection::readContentFromDisc()
 {
-    calcScripts.deleteAllChildObjects();
+    calcScripts.deleteChildren();
 
     if ( directory().isEmpty() )
     {
@@ -104,7 +104,7 @@ void RimScriptCollection::readContentFromDisc()
         }
     }
 
-    subDirectories.deleteAllChildObjects();
+    subDirectories.deleteChildren();
 
     if ( m_searchSubFolders() )
     {

ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp

@@ -245,7 +245,7 @@ RimSimWellInViewCollection::RimSimWellInViewCollection()
 //--------------------------------------------------------------------------------------------------
 RimSimWellInViewCollection::~RimSimWellInViewCollection()
 {
-    wells.deleteAllChildObjects();
+    wells.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimStimPlanColors.cpp

@@ -125,7 +125,7 @@ void RimStimPlanColors::loadDataAndUpdate()
 
         for ( auto legend : toBeDeleted )
         {
-            m_legendConfigurations.removeChildObject( legend );
+            m_legendConfigurations.removeChild( legend );
 
             delete legend;
         }

ApplicationLibCode/ProjectDataModel/RimSurfaceIntersectionBand.cpp

@@ -79,7 +79,7 @@ RimSurfaceIntersectionBand::RimSurfaceIntersectionBand()
 //--------------------------------------------------------------------------------------------------
 void RimSurfaceIntersectionBand::setSurfaces( RimSurface* surface1, RimSurface* surface2 )
 {
-    m_surfaces.clear();
+    m_surfaces.clearWithoutDelete();
 
     m_surfaces.push_back( surface1 );
     m_surfaces.push_back( surface2 );

ApplicationLibCode/ProjectDataModel/RimSurfaceIntersectionCollection.cpp

@@ -64,7 +64,7 @@ RimSurfaceIntersectionBand* RimSurfaceIntersectionCollection::addIntersectionBan
 //--------------------------------------------------------------------------------------------------
 std::vector<RimSurfaceIntersectionCurve*> RimSurfaceIntersectionCollection::surfaceIntersectionCurves() const
 {
-    return m_intersectionCurves.childObjects();
+    return m_intersectionCurves.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -72,7 +72,7 @@ std::vector<RimSurfaceIntersectionCurve*> RimSurfaceIntersectionCollection::surf
 //--------------------------------------------------------------------------------------------------
 std::vector<RimSurfaceIntersectionBand*> RimSurfaceIntersectionCollection::surfaceIntersectionBands() const
 {
-    return m_intersectionBands.childObjects();
+    return m_intersectionBands.children();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculation.cpp

@@ -129,7 +129,7 @@ RimUserDefinedCalculationVariable* RimUserDefinedCalculation::addVariable( const
 //--------------------------------------------------------------------------------------------------
 void RimUserDefinedCalculation::deleteVariable( RimUserDefinedCalculationVariable* calcVariable )
 {
-    m_variables.removeChildObject( calcVariable );
+    m_variables.removeChild( calcVariable );
 
     delete calcVariable;
 }
@@ -374,5 +374,5 @@ void RimUserDefinedCalculation::defineEditorAttribute( const caf::PdmFieldHandle
 //--------------------------------------------------------------------------------------------------
 std::vector<RimUserDefinedCalculationVariable*> RimUserDefinedCalculation::allVariables() const
 {
-    return m_variables.childObjects();
+    return m_variables.children();
 }

ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculationCollection.cpp

@@ -103,7 +103,7 @@ RimUserDefinedCalculation*
 void RimUserDefinedCalculationCollection::deleteCalculation( RimUserDefinedCalculation* calculation )
 {
     calculation->removeDependentObjects();
-    m_calculations.removeChildObject( calculation );
+    m_calculations.removeChild( calculation );
 
     rebuildCaseMetaData();
 
@@ -115,7 +115,7 @@ void RimUserDefinedCalculationCollection::deleteCalculation( RimUserDefinedCalcu
 //--------------------------------------------------------------------------------------------------
 std::vector<RimUserDefinedCalculation*> RimUserDefinedCalculationCollection::calculations() const
 {
-    return m_calculations.childObjects();
+    return m_calculations.children();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -139,7 +139,7 @@ RimUserDefinedCalculation* RimUserDefinedCalculationCollection::findCalculationB
 //--------------------------------------------------------------------------------------------------
 void RimUserDefinedCalculationCollection::deleteAllContainedObjects()
 {
-    m_calculations.deleteAllChildObjects();
+    m_calculations.deleteChildren();
 
     rebuildCaseMetaData();
 }

ApplicationLibCode/ProjectDataModel/RimVfpPlotCollection.cpp

@@ -70,15 +70,15 @@ void RimVfpPlotCollection::insertPlot( RimVfpPlot* vfpPlot, size_t index )
 //--------------------------------------------------------------------------------------------------
 std::vector<RimVfpPlot*> RimVfpPlotCollection::plots() const
 {
-    return m_vfpPlots.childObjects();
+    return m_vfpPlots.children();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimVfpPlotCollection::deleteAllChildObjects()
+void RimVfpPlotCollection::deleteChildren()
 {
-    m_vfpPlots.deleteAllChildObjects();
+    m_vfpPlots.deleteChildren();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -94,6 +94,6 @@ size_t RimVfpPlotCollection::plotCount() const
 //--------------------------------------------------------------------------------------------------
 void RimVfpPlotCollection::removePlot( RimVfpPlot* vfpPlot )
 {
-    m_vfpPlots.removeChildObject( vfpPlot );
+    m_vfpPlots.removeChild( vfpPlot );
     updateAllRequiredEditors();
 }

ApplicationLibCode/ProjectDataModel/RimVfpPlotCollection.h

@@ -37,7 +37,7 @@ public:
 
     void                     addPlot( RimVfpPlot* newPlot ) override;
     std::vector<RimVfpPlot*> plots() const override;
-    void                     deleteAllChildObjects();
+    void                     deleteChildren();
 
     size_t plotCount() const final;
     void   insertPlot( RimVfpPlot* vfpPlot, size_t index ) final;

ApplicationLibCode/ProjectDataModel/RimViewLinker.cpp

@@ -84,7 +84,7 @@ RimViewLinker::~RimViewLinker()
 {
     removeOverrides();
 
-    m_viewControllers.deleteAllChildObjects();
+    m_viewControllers.deleteChildren();
     RimGridView* masterView = m_masterView;
     m_masterView            = nullptr;
     if ( masterView ) masterView->updateAutoName();
@@ -313,7 +313,7 @@ void RimViewLinker::setMasterView( RimGridView* view )
     if ( previousViewController )
     {
         delete previousViewController;
-        this->m_viewControllers.removeChildObject( nullptr );
+        this->m_viewControllers.removeChild( nullptr );
     }
 
     this->removeOverrides();
@@ -673,7 +673,7 @@ void RimViewLinker::updatePropertyFilters( RimPropertyFilter* changedPropertyFil
 //--------------------------------------------------------------------------------------------------
 void RimViewLinker::removeViewController( RimViewController* viewController )
 {
-    m_viewControllers.removeChildObject( viewController );
+    m_viewControllers.removeChild( viewController );
 }
 
 //--------------------------------------------------------------------------------------------------