OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Rename several child() and children() functions

Browse Source
This commit is contained in:
Magne Sjaastad 2022-05-31 13:08:07 +02:00
parent c199f960e3
commit c74701b687
179 changed files with 429 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationLibCode/Application/RiaCompletionTypeCalculationScheduler.cpp
View File

@ -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 );
}

2
ApplicationLibCode/Application/Tools/RiaProjectModifier.cpp
View File

@ -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 )
{

2
ApplicationLibCode/Commands/EclipseCommands/RicEclipseShowOnlyFaultFeature.cpp
View File

@ -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 )
{

6
ApplicationLibCode/Commands/ExportCommands/RicAdvancedSnapshotExportFeature.cpp
View File

@ -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;
}

2
ApplicationLibCode/Commands/ExportCommands/RicExportToLasFileResampleUi.cpp
View File

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

8
ApplicationLibCode/Commands/FractureCommands/RicCreateMultipleFracturesUi.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/Commands/RicCloseCaseFeature.cpp
View File

@ -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
{

2
ApplicationLibCode/Commands/RicDeleteItemExec.cpp
View File

@ -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 );

2
ApplicationLibCode/Commands/RicDeleteItemFeature.cpp
View File

@ -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++ )
{

2
ApplicationLibCode/Commands/RicElasticPropertiesImportTools.cpp
View File

@ -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() )
{

2
ApplicationLibCode/Commands/SsiHubImportCommands/RimOilFieldEntry.cpp
View File

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

2
ApplicationLibCode/Commands/SsiHubImportCommands/RimOilRegionEntry.cpp
View File

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

6
ApplicationLibCode/Commands/SsiHubImportCommands/RimWellPathImport.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

8
ApplicationLibCode/Commands/SsiHubImportCommands/RiuWellImportWizard.cpp
View File

@ -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" );

2
ApplicationLibCode/Commands/ToggleCommands/RicToggleItemsOnOthersOffFeature.cpp
View File

@ -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;
}

2
ApplicationLibCode/Commands/ViewLink/RicDeleteAllLinkedViewsFeature.cpp
View File

@ -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();

2
ApplicationLibCode/Commands/ViewLink/RicUnLinkViewFeature.cpp
View File

@ -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;
}

2
ApplicationLibCode/FileInterface/RifEclipseInputPropertyLoader.cpp
View File

@ -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" );

6
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp
View File

@ -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;
}

4
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotCollection.cpp
View File

@ -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();
}

4
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Annotations/RimAnnotationGroupCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp
View File

@ -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;
}

6
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.cpp
View File

@ -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 );
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimEclipsePropertyFilterCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimGeoMechPropertyFilterCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.cpp
View File

@ -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;
}

4
ApplicationLibCode/ProjectDataModel/Completions/Rim3dWellLogCurveCollection.cpp
View File

@ -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 );
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/Completions/RimEnsembleFractureStatisticsCollection.cpp
View File

@ -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();
}

4
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp
View File

@ -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();
}

2
ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/Completions/RimPerforationCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/Completions/RimSimWellFractureCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplateCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/Completions/RimWellPathFractureCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimAbstractCorrelationPlot.cpp
View File

@ -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();

8
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlotCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Faults/RimFaultInViewCollection.cpp
View File

@ -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() );

12
ApplicationLibCode/ProjectDataModel/Faults/RimFaultRASettings.cpp
View File

@ -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;

6
ApplicationLibCode/ProjectDataModel/Flow/RimFlowPlotCollection.cpp
View File

@ -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_storedFlowCharacteristicsPlots.deleteAllChildObjects();
m_storedWellAllocPlots.deleteChildren();
m_storedFlowCharacteristicsPlots.deleteChildren();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Flow/RimWellDistributionPlotCollection.cpp
View File

@ -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();

2
ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechCase.cpp
View File

@ -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 );

2
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapViewCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechModels.cpp
View File

@ -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 );
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechPartCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp
View File

@ -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_yAxisProperties.removeChildObject( yAxisProperties );
m_xAxisProperties.removeChild( xAxisProperties );
m_yAxisProperties.removeChild( yAxisProperties );
m_yAxisProperties = xAxisProperties;
m_xAxisProperties = yAxisProperties;

4
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotCollection.cpp
View File

@ -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();
}

10
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
View File

@ -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_yAxisProperty.removeChildObject( yAxisProperties );
m_xAxisProperty.removeChild( xAxisProperties );
m_yAxisProperty.removeChild( yAxisProperties );
m_yAxisProperty = xAxisProperties;
m_xAxisProperty = yAxisProperties;

4
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

8
ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionCollection.cpp
View File

@ -79,8 +79,8 @@ RimIntersectionCollection::RimIntersectionCollection()
//--------------------------------------------------------------------------------------------------
RimIntersectionCollection::~RimIntersectionCollection()
{
m_intersections.deleteAllChildObjects();
m_intersectionBoxes.deleteAllChildObjects();
m_intersections.deleteChildren();
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();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionResultsDefinitionCollection.cpp
View File

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

6
ApplicationLibCode/ProjectDataModel/Parameters/RimParameterGroup.cpp
View File

@ -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 )
{

12
ApplicationLibCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFolderItem.cpp
View File

@ -56,8 +56,8 @@ RimPlotTemplateFolderItem::~RimPlotTemplateFolderItem()
//--------------------------------------------------------------------------------------------------
void RimPlotTemplateFolderItem::createRootFolderItemsFromFolderPaths( const QStringList& folderPaths )
{
m_fileNames.deleteAllChildObjects();
m_subFolders.deleteAllChildObjects();
m_fileNames.deleteChildren();
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_subFolders.deleteAllChildObjects();
m_fileNames.deleteChildren();
m_subFolders.deleteChildren();
if ( m_folderName().path().isEmpty() )
{

6
ApplicationLibCode/ProjectDataModel/Rim2dIntersectionViewCollection.cpp
View File

@ -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

2
ApplicationLibCode/ProjectDataModel/RimCaseCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimColorLegend.cpp
View File

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

6
ApplicationLibCode/ProjectDataModel/RimColorLegendCollection.cpp
View File

@ -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 );

4
ApplicationLibCode/ProjectDataModel/RimCommandObject.cpp
View File

@ -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++ )
{

4
ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunction.cpp
View File

@ -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 )
{

2
ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunctionCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/RimCustomObjectiveFunctionWeight.cpp
View File

@ -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();

14
ApplicationLibCode/ProjectDataModel/RimDepthTrackPlot.cpp
View File

@ -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();
rhs.m_plots.clear();
auto plots = rhs.m_plots.children();
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 );
}

6
ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -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,

6
ApplicationLibCode/ProjectDataModel/RimEclipseCaseCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseContourMapViewCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseInputPropertyCollection.cpp
View File

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

4
ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -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();

2
ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCaseCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -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 );

4
ApplicationLibCode/ProjectDataModel/RimEnsembleFractureStatisticsPlotCollection.cpp
View File

@ -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();
}

4
ApplicationLibCode/ProjectDataModel/RimFormationNamesCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/RimGridCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/RimGridStatisticsPlot.cpp
View File

@ -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() ) );

4
ApplicationLibCode/ProjectDataModel/RimGridStatisticsPlotCollection.cpp
View File

@ -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();
}

2
ApplicationLibCode/ProjectDataModel/RimGridView.cpp
View File

@ -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;

6
ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -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,
poroModel,
caseCollection->reservoirs.childObjects() );
RigCaseCellResultsData::copyResultsMetaDataFromMainCase( rigCaseData, poroModel, caseCollection->reservoirs.children() );
// "Load" the statistical cases

14
ApplicationLibCode/ProjectDataModel/RimMultiPlot.cpp
View File

@ -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();
rhs.m_plots.clear();
std::vector<RimPlot*> plots = rhs.m_plots.children();
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();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ProjectDataModel/RimMultiPlotCollection.cpp
View File

@ -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();
}

12
ApplicationLibCode/ProjectDataModel/RimObservedDataCollection.cpp
View File

@ -61,8 +61,8 @@ RimObservedDataCollection::RimObservedDataCollection()
//--------------------------------------------------------------------------------------------------
RimObservedDataCollection::~RimObservedDataCollection()
{
m_observedDataArray.deleteAllChildObjects();
m_observedFmuRftArray.deleteAllChildObjects();
m_observedDataArray.deleteChildren();
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();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/RimOilField.cpp
View File

@ -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 );
}
}

4
ApplicationLibCode/ProjectDataModel/RimPlotAxisProperties.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ProjectDataModel/RimPltPlotCollection.cpp
View File

@ -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();
}

20
ApplicationLibCode/ProjectDataModel/RimProject.cpp
View File

@ -249,17 +249,17 @@ void RimProject::close()
mainPlotCollection()->deleteAllContainedObjects();
}
oilFields.deleteAllChildObjects();
oilFields.deleteChildren();
oilFields.push_back( new RimOilField );
casesObsolete.deleteAllChildObjects();
caseGroupsObsolete.deleteAllChildObjects();
casesObsolete.deleteChildren();
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->subDirectories().deleteAllChildObjects();
scriptCollection->calcScripts().deleteChildren();
scriptCollection->subDirectories().deleteChildren();
QStringList pathList = scriptDirectories.split( ';' );
foreach ( QString path, pathList )

2
ApplicationLibCode/ProjectDataModel/RimProject.h
View File

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

4
ApplicationLibCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -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

6
ApplicationLibCode/ProjectDataModel/RimRftPlotCollection.cpp
View File

@ -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();
}

8
ApplicationLibCode/ProjectDataModel/RimScriptCollection.cpp
View File

@ -53,8 +53,8 @@ RimScriptCollection::RimScriptCollection()
//--------------------------------------------------------------------------------------------------
RimScriptCollection::~RimScriptCollection()
{
calcScripts.deleteAllChildObjects();
subDirectories.deleteAllChildObjects();
calcScripts.deleteChildren();
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() )
{

2
ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimStimPlanColors.cpp
View File

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

2
ApplicationLibCode/ProjectDataModel/RimSurfaceIntersectionBand.cpp
View File

@ -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 );

4
ApplicationLibCode/ProjectDataModel/RimSurfaceIntersectionCollection.cpp
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculation.cpp
View File

@ -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();
}

6
ApplicationLibCode/ProjectDataModel/RimUserDefinedCalculationCollection.cpp
View File

@ -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();
}

8
ApplicationLibCode/ProjectDataModel/RimVfpPlotCollection.cpp
View File

@ -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();
}

2
ApplicationLibCode/ProjectDataModel/RimVfpPlotCollection.h
View File

@ -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;

6
ApplicationLibCode/ProjectDataModel/RimViewLinker.cpp
View File

@ -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 );
}
//--------------------------------------------------------------------------------------------------

Some files were not shown because too many files have changed in this diff Show More