/// <summary>
/// Creates the observers.
/// </summary>
protected virtual void CreateObservers()
{
assessmentSectionObserver = new Observer(UpdateUpdateReferenceLineMapData)
{
Observable = AssessmentSection
};
referenceLineObserver = new Observer(UpdateUpdateReferenceLineMapData)
{
Observable = AssessmentSection.ReferenceLine
};
dikeProfilesObserver = new Observer(UpdateDikeProfilesMapData)
{
Observable = FailureMechanism.DikeProfiles
};
calculationInputObserver = new RecursiveObserver <CalculationGroup, GrassCoverErosionInwardsInput>(
UpdateCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <GrassCoverErosionInwardsCalculation>()
.Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
calculationObserver = new RecursiveObserver <CalculationGroup, GrassCoverErosionInwardsCalculation>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
dikeProfileObserver = new RecursiveObserver <DikeProfileCollection, DikeProfile>(UpdateDikeProfilesMapData, dpc => dpc)
{
Observable = FailureMechanism.DikeProfiles
};
}
protected override void InitializeObservers()
{
base.InitializeObservers();
surfaceLineObserver = new RecursiveObserver <PipingSurfaceLineCollection, PipingSurfaceLine>(UpdateGenerateCalculationsButtonState, rpslc => rpslc)
{
Observable = FailureMechanism.SurfaceLines
};
stochasticSoilModelsObserver = new Observer(() =>
{
PrefillComboBoxListItemsAtColumnLevel();
UpdateComboBoxColumns();
UpdateGenerateCalculationsButtonState();
})
{
Observable = FailureMechanism.StochasticSoilModels
};
stochasticSoilProfileObserver = new RecursiveObserver <PipingStochasticSoilModelCollection, PipingStochasticSoilProfile>(
() => DataGridViewControl.RefreshDataGridView(),
ssmc => ssmc.SelectMany(ssm => ssm.StochasticSoilProfiles))
{
Observable = FailureMechanism.StochasticSoilModels
};
}
private void CreateObservers()
{
duneLocationsObserver = new Observer(UpdateFeatures)
{
Observable = failureMechanism.DuneLocations
};
userDefinedTargetProbabilitiesCollectionObserver = new Observer(() =>
{
DeleteTargetProbabilitiesObservers();
CreateTargetProbabilitiesObservers();
UpdateFeatures();
})
{
Observable = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities
};
userDefinedTargetProbabilitiesObserver = new RecursiveObserver <IObservableEnumerable <DuneLocationCalculationsForTargetProbability>, DuneLocationCalculationsForTargetProbability>(
UpdateFeatures, tp => tp)
{
Observable = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities
};
calculationsForTargetProbabilityObservers = new List <RecursiveObserver <IObservableEnumerable <DuneLocationCalculation>, DuneLocationCalculation> >();
CreateTargetProbabilitiesObservers();
}
/// <summary>
/// Creates a new instance of <see cref="HydraulicBoundaryCalculationsView"/>.
/// </summary>
/// <param name="calculations">The calculations to show in the view.</param>
/// <param name="assessmentSection">The assessment section which the calculations belong to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
protected HydraulicBoundaryCalculationsView(IObservableEnumerable <HydraulicBoundaryLocationCalculation> calculations,
IAssessmentSection assessmentSection)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
AssessmentSection = assessmentSection;
calculationsObserver = new Observer(UpdateDataGridViewDataSource);
calculationObserver = new RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation>(HandleHydraulicBoundaryLocationCalculationUpdate, hblc => hblc);
this.calculations = calculations;
calculationsObserver.Observable = calculations;
calculationObserver.Observable = calculations;
UpdateDataGridViewDataSource();
}
/// <summary>
/// Creates a new instance of <see cref="FailureMechanismResultObserver{TFailureMechanism, TSectionResult}"/>.
/// </summary>
/// <param name="failureMechanism">The <typeparamref name="TFailureMechanism"/> to observe.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
public FailureMechanismResultObserver(TFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
failureMechanismObserver = new Observer(NotifyObservers)
{
Observable = failureMechanism
};
failureMechanismAssemblyResultObserver = new Observer(NotifyObservers)
{
Observable = failureMechanism.AssemblyResult
};
failureMechanismSectionResultObserver = new Observer(NotifyObservers)
{
Observable = failureMechanism.SectionResults
};
failureMechanismSectionResultsObserver = new RecursiveObserver <IObservableEnumerable <TSectionResult>, TSectionResult>(
NotifyObservers,
sr => sr)
{
Observable = failureMechanism.SectionResults
};
}
/// <summary>
/// Creates the observers.
/// </summary>
protected virtual void CreateObservers()
{
assessmentSectionObserver = new Observer(UpdateReferenceLineData)
{
Observable = AssessmentSection
};
referenceLineObserver = new Observer(UpdateReferenceLineData)
{
Observable = AssessmentSection.ReferenceLine
};
foreshoreProfilesObserver = new Observer(UpdateForeshoreProfilesMapData)
{
Observable = FailureMechanism.ForeshoreProfiles
};
calculationInputObserver = new RecursiveObserver <CalculationGroup, WaveConditionsInput>(
UpdateCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <WaveImpactAsphaltCoverWaveConditionsCalculation>()
.Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
calculationObserver = new RecursiveObserver <CalculationGroup, WaveImpactAsphaltCoverWaveConditionsCalculation>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
foreshoreProfileObserver = new RecursiveObserver <ForeshoreProfileCollection, ForeshoreProfile>(UpdateForeshoreProfilesMapData, coll => coll)
{
Observable = FailureMechanism.ForeshoreProfiles
};
}
/// <summary>
/// Creates a new instance of <see cref="PipingFailureMechanismResultView"/>.
/// </summary>
/// <param name="failureMechanismSectionResults">The collection of <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to
/// show in the view.</param>
/// <param name="failureMechanism">The failure mechanism the results belong to.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism results belong to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public PipingFailureMechanismResultView(IObservableEnumerable <AdoptableWithProfileProbabilityFailureMechanismSectionResult> failureMechanismSectionResults,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(failureMechanismSectionResults, failureMechanism, assessmentSection, PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism)
{
// The concat is needed to observe the input of calculations in child groups.
calculationInputsObserver = new RecursiveObserver <CalculationGroup, ICalculationInput>(
UpdateInternalViewData,
cg => cg.Children.Concat <object>(cg.Children
.OfType <IPipingCalculationScenario <PipingInput> >()
.Select(c => c.InputParameters)))
{
Observable = failureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, ICalculationBase>(
UpdateInternalViewData,
c => c.Children)
{
Observable = failureMechanism.CalculationsGroup
};
scenarioConfigurationsPerSectionObserver = new RecursiveObserver <IObservableEnumerable <PipingScenarioConfigurationPerFailureMechanismSection>, PipingScenarioConfigurationPerFailureMechanismSection>(
UpdateInternalViewData,
sc => sc)
{
Observable = failureMechanism.ScenarioConfigurationsPerFailureMechanismSection
};
}
/// <summary>
/// Creates a new instance of <see cref="DuneLocationCalculationsView"/>.
/// </summary>
/// <param name="calculations">The calculations to show in the view.</param>
/// <param name="failureMechanism">The failure mechanism which the calculations belong to.</param>
/// <param name="assessmentSection">The assessment section which the calculations belong to.</param>
/// <param name="getTargetProbabilityFunc"><see cref="Func{TResult}"/> for getting the target probability to use during calculations.</param>
/// <param name="getCalculationIdentifierFunc"><see cref="Func{TResult}"/> for getting the calculation identifier to use in all messages.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public DuneLocationCalculationsView(IObservableEnumerable <DuneLocationCalculation> calculations,
DuneErosionFailureMechanism failureMechanism,
IAssessmentSection assessmentSection,
Func <double> getTargetProbabilityFunc,
Func <string> getCalculationIdentifierFunc)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (getTargetProbabilityFunc == null)
{
throw new ArgumentNullException(nameof(getTargetProbabilityFunc));
}
if (getCalculationIdentifierFunc == null)
{
throw new ArgumentNullException(nameof(getCalculationIdentifierFunc));
}
InitializeComponent();
this.calculations = calculations;
this.getTargetProbabilityFunc = getTargetProbabilityFunc;
this.getCalculationIdentifierFunc = getCalculationIdentifierFunc;
FailureMechanism = failureMechanism;
AssessmentSection = assessmentSection;
duneLocationCalculationsObserver = new Observer(UpdateDataGridViewDataSource)
{
Observable = calculations
};
duneLocationCalculationObserver = new RecursiveObserver <IObservableEnumerable <DuneLocationCalculation>, DuneLocationCalculation>(() => dataGridViewControl.RefreshDataGridView(), list => list)
{
Observable = calculations
};
failureMechanismObserver = new Observer(UpdateCalculateForSelectedButton)
{
Observable = failureMechanism
};
UpdateDataGridViewDataSource();
}
private void CreateObservers()
{
failureMechanismObserver = new Observer(UpdateFeatures)
{
Observable = failureMechanism
};
sectionResultObserver = new RecursiveObserver <IObservableEnumerable <TSectionResult>, TSectionResult>(UpdateFeatures, sr => sr)
{
Observable = failureMechanism.SectionResults
};
}
private void CreateObservers()
{
failureMechanismContributionObserver = new Observer(UpdateFeatures)
{
Observable = assessmentSection.FailureMechanismContribution
};
hydraulicBoundaryLocationsObserver = new Observer(UpdateFeatures)
{
Observable = assessmentSection.HydraulicBoundaryDatabase.Locations
};
waterLevelCalculationsForSignalFloodingProbabilityObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, UpdateFeatures);
waterLevelCalculationsForMaximumAllowableFloodingProbabilityObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, UpdateFeatures);
waterLevelForUserDefinedTargetProbabilitiesCollectionObserver = new Observer(() =>
{
DeleteTargetProbabilitiesObservers(waterLevelCalculationsForTargetProbabilityObservers);
CreateTargetProbabilitiesObservers(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities, waterLevelCalculationsForTargetProbabilityObservers);
UpdateFeatures();
})
{
Observable = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities
};
waveHeightForUserDefinedTargetProbabilitiesCollectionObserver = new Observer(() =>
{
DeleteTargetProbabilitiesObservers(waveHeightCalculationsForTargetProbabilityObservers);
CreateTargetProbabilitiesObservers(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities, waveHeightCalculationsForTargetProbabilityObservers);
UpdateFeatures();
})
{
Observable = assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities
};
waterLevelForUserDefinedTargetProbabilitiesObserver = new RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability>, HydraulicBoundaryLocationCalculationsForTargetProbability>(
UpdateFeatures, tp => tp)
{
Observable = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities
};
waveHeightForUserDefinedTargetProbabilitiesObserver = new RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability>, HydraulicBoundaryLocationCalculationsForTargetProbability>(
UpdateFeatures, tp => tp)
{
Observable = assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities
};
waterLevelCalculationsForTargetProbabilityObservers = new List <RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> >();
CreateTargetProbabilitiesObservers(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities, waterLevelCalculationsForTargetProbabilityObservers);
waveHeightCalculationsForTargetProbabilityObservers = new List <RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> >();
CreateTargetProbabilitiesObservers(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities, waveHeightCalculationsForTargetProbabilityObservers);
}
private void CreateObservers()
{
failureMechanismObserver = new Observer(UpdateFailureMechanismMapData)
{
Observable = FailureMechanism
};
assessmentSectionObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection
};
referenceLineObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection.ReferenceLine
};
surfaceLinesObserver = new Observer(UpdateSurfaceLinesMapData)
{
Observable = FailureMechanism.SurfaceLines
};
stochasticSoilModelsObserver = new Observer(UpdateStochasticSoilModelsMapData)
{
Observable = FailureMechanism.StochasticSoilModels
};
semiProbabilisticCalculationInputObserver = new RecursiveObserver <CalculationGroup, SemiProbabilisticPipingInput>(
UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <SemiProbabilisticPipingCalculationScenario>().Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
probabilisticCalculationInputObserver = new RecursiveObserver <CalculationGroup, ProbabilisticPipingInput>(
UpdateProbabilisticCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <ProbabilisticPipingCalculationScenario>().Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(() =>
{
UpdateSemiProbabilisticCalculationsMapData();
UpdateProbabilisticCalculationsMapData();
}, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
semiProbabilisticCalculationObserver = new RecursiveObserver <CalculationGroup, SemiProbabilisticPipingCalculationScenario>(UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
probabilisticCalculationObserver = new RecursiveObserver <CalculationGroup, ProbabilisticPipingCalculationScenario>(UpdateProbabilisticCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
surfaceLineObserver = new RecursiveObserver <PipingSurfaceLineCollection, PipingSurfaceLine>(UpdateSurfaceLinesMapData, rpslc => rpslc)
{
Observable = FailureMechanism.SurfaceLines
};
}
/// <summary>
/// Creates a new instance of <see cref="ChartControl"/>.
/// </summary>
public ChartControl()
{
InitializeComponent();
SetFonts();
InitializePlotView();
panToolStripButton.PerformClick();
chartDataCollectionObserver = new RecursiveObserver <ChartDataCollection, ChartDataCollection>(HandleChartDataCollectionChange, cdc => cdc.Collection);
}
/// <summary>
/// Creates a new instance of <see cref="FailureMechanismResultView{TSectionResult,TSectionResultRow,TFailureMechanism}"/>.
/// </summary>
/// <param name="failureMechanismSectionResults">The collection of <typeparamref name="TSectionResult"/> to
/// show in the view.</param>
/// <param name="failureMechanism">The failure mechanism the results belong to.</param>
/// <param name="assessmentSection">The assessment section the results belong to.</param>
/// <param name="performFailureMechanismAssemblyFunc">The function to perform an assembly on the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
protected FailureMechanismResultView(IObservableEnumerable <TSectionResult> failureMechanismSectionResults,
TFailureMechanism failureMechanism,
IAssessmentSection assessmentSection,
Func <TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> performFailureMechanismAssemblyFunc)
{
if (failureMechanismSectionResults == null)
{
throw new ArgumentNullException(nameof(failureMechanismSectionResults));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (performFailureMechanismAssemblyFunc == null)
{
throw new ArgumentNullException(nameof(performFailureMechanismAssemblyFunc));
}
InitializeComponent();
FailureMechanism = failureMechanism;
AssessmentSection = assessmentSection;
this.failureMechanismSectionResults = failureMechanismSectionResults;
this.performFailureMechanismAssemblyFunc = performFailureMechanismAssemblyFunc;
failureMechanismObserver = new Observer(UpdateInternalViewData)
{
Observable = failureMechanism
};
failureMechanismSectionResultObserver = new Observer(UpdateInternalViewData)
{
Observable = failureMechanismSectionResults
};
failureMechanismSectionResultsObserver = new RecursiveObserver <IObservableEnumerable <TSectionResult>, TSectionResult>(
UpdateSectionResultRows,
sr => sr)
{
Observable = failureMechanismSectionResults
};
InitializeComboBox();
}
/// <summary>
/// Creates a new instance of <see cref="HydraulicBoundaryLocationCalculationsProperties"/>.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculations">The collection of hydraulic boundary location calculations to set as data.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculations"/> is <c>null</c>.</exception>
protected HydraulicBoundaryLocationCalculationsProperties(IObservableEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations)
{
if (hydraulicBoundaryLocationCalculations == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryLocationCalculations));
}
Data = hydraulicBoundaryLocationCalculations;
hydraulicBoundaryLocationCalculationsObserver = new RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation>(OnRefreshRequired, hblc => hblc)
{
Observable = hydraulicBoundaryLocationCalculations
};
}
/// <summary>
/// Creates a new instance of <see cref="MapControl"/>.
/// </summary>
public MapControl()
{
InitializeComponent();
SetFonts();
InitializeMap();
panToolStripButton.PerformClick();
showCoordinatesToolStripButton.PerformClick();
mapDataCollectionObserver = new RecursiveObserver <MapDataCollection, MapDataCollection>(HandleMapDataCollectionChange, mdc => mdc.Collection);
backGroundMapDataObserver = new Observer(HandleBackgroundMapDataChange);
InitializeUpdateTimer();
}
/// <inheritdoc />
/// <summary>
/// Creates a new instance of <see cref="CalculatableFailureMechanismResultObserver{TFailureMechanism,TSectionResult,TCalculation}"/>.
/// </summary>
public CalculatableFailureMechanismResultObserver(TFailureMechanism failureMechanism)
: base(failureMechanism)
{
calculationObserver = new RecursiveObserver <CalculationGroup, ICalculationBase>(
NotifyObservers,
c => c.Children);
calculationInputObserver = new RecursiveObserver <CalculationGroup, ICalculationInput>(
NotifyObservers,
cg => cg.Children.Concat <object>(cg.Children
.OfType <TCalculation>()
.Select(c => c.InputParameters)));
CalculationGroup observableGroup = failureMechanism.CalculationsGroup;
calculationObserver.Observable = observableGroup;
calculationInputObserver.Observable = observableGroup;
}
protected virtual void CreateObservers()
{
assessmentSectionObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection
};
referenceLineObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection.ReferenceLine
};
foreshoreProfilesObserver = new Observer(UpdateForeshoreProfilesMapData)
{
Observable = FailureMechanism.ForeshoreProfiles
};
structuresObserver = new Observer(UpdateStructuresMapData)
{
Observable = FailureMechanism.StabilityPointStructures
};
calculationInputObserver = new RecursiveObserver <CalculationGroup, StabilityPointStructuresInput>(
UpdateCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <StructuresCalculation <StabilityPointStructuresInput> >()
.Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
calculationObserver = new RecursiveObserver <CalculationGroup, StructuresCalculation <StabilityPointStructuresInput> >(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
foreshoreProfileObserver = new RecursiveObserver <ForeshoreProfileCollection, ForeshoreProfile>(UpdateForeshoreProfilesMapData, coll => coll)
{
Observable = FailureMechanism.ForeshoreProfiles
};
structureObserver = new RecursiveObserver <StructureCollection <StabilityPointStructure>, StabilityPointStructure>(UpdateStructuresMapData, coll => coll)
{
Observable = FailureMechanism.StabilityPointStructures
};
}
/// <summary>
/// Creates a new instance of <see cref="CalculatableFailureMechanismSectionResultsMapLayer{TFailureMechanism,TSectionResult,TCalculationInput}"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to get the data from.</param>
/// <param name="performAssemblyFunc">The <see cref="Func{T,T2}"/> used to assemble the result of a section result.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public CalculatableFailureMechanismSectionResultsMapLayer(
TFailureMechanism failureMechanism, Func <TSectionResult, FailureMechanismSectionAssemblyResult> performAssemblyFunc)
: base(failureMechanism, performAssemblyFunc)
{
calculationGroupsObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(UpdateFeatures, pcg => pcg.Children)
{
Observable = failureMechanism.CalculationsGroup
};
calculationInputsObserver = new RecursiveObserver <CalculationGroup, TCalculationInput>(
UpdateFeatures, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <ICalculation <TCalculationInput> >().Select(pc => pc.InputParameters)))
{
Observable = failureMechanism.CalculationsGroup
};
calculationScenariosObserver = new RecursiveObserver <CalculationGroup, ICalculationScenario>(UpdateFeatures, pcg => pcg.Children)
{
Observable = failureMechanism.CalculationsGroup
};
}
public void DefaultConstructor_DefaultValues()
{
// Setup
var counter = 0;
// Call
using (var recursiveObserver = new RecursiveObserver <TestContainer, TestContainer>(() =>
{
counter++;
}, GetChildren))
{
// Assert
Assert.IsInstanceOf <IObserver>(recursiveObserver);
Assert.IsNull(recursiveObserver.Observable);
Assert.AreEqual(0, counter);
recursiveObserver.UpdateObserver();
Assert.AreEqual(1, counter);
}
}
public virtual void Attach(IObserver observer)
{
if (!observers.Any())
{
if (!(LocationCalculationsEnumerationToObserve is TObservable))
{
locationCalculationsEnumerationObserver = new Observer(NotifyObservers)
{
Observable = LocationCalculationsEnumerationToObserve
};
}
locationCalculationsObserver = new RecursiveObserver <IObservableEnumerable <TObservable>, TObservable>(NotifyObservers, enumerable => enumerable)
{
Observable = LocationCalculationsEnumerationToObserve
};
}
observers.Add(observer);
}
/// <summary>
/// Creates a new instance of <see cref="GrassCoverErosionInwardsFailureMechanismResultView"/>.
/// </summary>
/// <param name="failureMechanismSectionResults">The collection of
/// <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to show in the view.</param>
/// <param name="failureMechanism">The failure mechanism the results belong to.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism results belong to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public GrassCoverErosionInwardsFailureMechanismResultView(IObservableEnumerable <AdoptableWithProfileProbabilityFailureMechanismSectionResult> failureMechanismSectionResults,
GrassCoverErosionInwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(failureMechanismSectionResults, failureMechanism, assessmentSection, GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism)
{
// The concat is needed to observe the input of calculations in child groups.
calculationInputsObserver = new RecursiveObserver <CalculationGroup, ICalculationInput>(
UpdateInternalViewData,
cg => cg.Children.Concat <object>(cg.Children
.OfType <GrassCoverErosionInwardsCalculationScenario>()
.Select(c => c.InputParameters)))
{
Observable = failureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, ICalculationBase>(
UpdateInternalViewData,
c => c.Children)
{
Observable = failureMechanism.CalculationsGroup
};
}
/// <summary>
/// Creates a new instance of <see cref="DuneLocationCalculationsForUserDefinedTargetProbabilityProperties"/>.
/// </summary>
/// <param name="calculationsForTargetProbability">The <see cref="DuneLocationCalculationsForTargetProbability"/> to show the properties for.</param>
/// <param name="targetProbabilityChangeHandler">The <see cref="IObservablePropertyChangeHandler"/> for when the target probability changes.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public DuneLocationCalculationsForUserDefinedTargetProbabilityProperties(DuneLocationCalculationsForTargetProbability calculationsForTargetProbability,
IObservablePropertyChangeHandler targetProbabilityChangeHandler)
{
if (calculationsForTargetProbability == null)
{
throw new ArgumentNullException(nameof(calculationsForTargetProbability));
}
if (targetProbabilityChangeHandler == null)
{
throw new ArgumentNullException(nameof(targetProbabilityChangeHandler));
}
Data = calculationsForTargetProbability;
this.targetProbabilityChangeHandler = targetProbabilityChangeHandler;
calculationsObserver = new RecursiveObserver <IObservableEnumerable <DuneLocationCalculation>, DuneLocationCalculation>(OnRefreshRequired, list => list)
{
Observable = calculationsForTargetProbability.DuneLocationCalculations
};
}
/// <summary>
/// Creates the observers.
/// </summary>
protected virtual void CreateObservers()
{
assessmentSectionObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection
};
referenceLineObserver = new Observer(UpdateReferenceLineMapData)
{
Observable = AssessmentSection.ReferenceLine
};
surfaceLinesObserver = new Observer(UpdateSurfaceLinesMapData)
{
Observable = FailureMechanism.SurfaceLines
};
stochasticSoilModelsObserver = new Observer(UpdateStochasticSoilModelsMapData)
{
Observable = FailureMechanism.StochasticSoilModels
};
calculationInputObserver = new RecursiveObserver <CalculationGroup, MacroStabilityInwardsInput>(
UpdateCalculationsMapData, pcg => pcg.Children.Concat <object>(pcg.Children.OfType <MacroStabilityInwardsCalculationScenario>().Select(pc => pc.InputParameters)))
{
Observable = FailureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, CalculationGroup>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
calculationObserver = new RecursiveObserver <CalculationGroup, MacroStabilityInwardsCalculationScenario>(UpdateCalculationsMapData, pcg => pcg.Children)
{
Observable = FailureMechanism.CalculationsGroup
};
surfaceLineObserver = new RecursiveObserver <MacroStabilityInwardsSurfaceLineCollection, MacroStabilityInwardsSurfaceLine>(UpdateSurfaceLinesMapData, rpslc => rpslc)
{
Observable = FailureMechanism.SurfaceLines
};
}
public void RecursiveObserverObservingItemsInContainers_RecursiveObserverDispose_UpdateObserversActionShouldNoLongerBePerformed(int nestingLevel)
{
// Given
var counter = 0;
var rootContainer = new TestContainer();
TestContainer currentNestedContainer = rootContainer;
var currentTestObservable = new TestObservable();
InitializeHierarchy(nestingLevel, ref currentNestedContainer, ref currentTestObservable);
var recursiveObserver = new RecursiveObserver <TestContainer, TestObservable>(() => counter++, GetChildren)
{
Observable = rootContainer
};
// When
recursiveObserver.Dispose();
currentTestObservable.NotifyObservers();
// Then
Assert.AreEqual(0, counter);
Assert.IsNull(recursiveObserver.Observable);
}
public void RecursiveObserverObservingContainers_RootContainerSetAndThenUnset_UpdateObserversActionShouldNoLongerBePerformed(int nestingLevel)
{
// Given
var counter = 0;
var rootContainer = new TestContainer();
TestContainer currentNestedContainer = rootContainer;
var currentTestObservable = new TestObservable();
InitializeHierarchy(nestingLevel, ref currentNestedContainer, ref currentTestObservable);
using (var recursiveObserver = new RecursiveObserver <TestContainer, TestContainer>(() => counter++, GetChildren)
{
Observable = rootContainer
})
{
// When
recursiveObserver.Observable = null;
currentNestedContainer.NotifyObservers();
// Then
Assert.AreEqual(0, counter);
}
}
/// <summary>
/// Creates a new instance of <see cref="StructuresFailureMechanismResultView{TFailureMechanism,TStructuresInput}"/>.
/// </summary>
/// <param name="failureMechanismSectionResults">The collection of <see cref="AdoptableFailureMechanismSectionResult"/> to
/// show in the view.</param>
/// <param name="failureMechanism">The failure mechanism the results belong to.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism results belong to.</param>
/// <param name="performFailureMechanismAssemblyFunc">The function to perform an assembly on the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public StructuresFailureMechanismResultView(IObservableEnumerable <AdoptableFailureMechanismSectionResult> failureMechanismSectionResults,
TFailureMechanism failureMechanism,
IAssessmentSection assessmentSection,
Func <TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> performFailureMechanismAssemblyFunc)
: base(failureMechanismSectionResults, failureMechanism, assessmentSection, performFailureMechanismAssemblyFunc)
{
// The concat is needed to observe the input of calculations in child groups.
calculationInputsObserver = new RecursiveObserver <CalculationGroup, ICalculationInput>(
UpdateInternalViewData,
cg => cg.Children.Concat(cg.Children
.OfType <StructuresCalculationScenario <TStructuresInput> >()
.Select(scenario => scenario.InputParameters)
.Cast <object>()))
{
Observable = failureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, ICalculationBase>(
UpdateInternalViewData,
c => c.Children)
{
Observable = failureMechanism.CalculationsGroup
};
}
public void CreateHydraulicBoundaryLocationCalculationsObserver_WithData_ReturnsRecursiveObserver()
{
// Setup
var calculations = new ObservableList <HydraulicBoundaryLocationCalculation>();
// Call
using (RecursiveObserver <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> observer =
ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(calculations, () => {}))
{
// Assert
Assert.AreSame(calculations, observer.Observable);
}
}
/// <summary>
/// Creates a new instance of <see cref="AssessmentSectionResultObserver"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="AssessmentSection"/> to observe.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
public AssessmentSectionResultObserver(AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
this.assessmentSection = assessmentSection;
assessmentSectionObserver = new Observer(() =>
{
ResubscribeFailureMechanismObservers(assessmentSection);
NotifyObservers();
})
{
Observable = assessmentSection
};
referenceLineObserver = new Observer(NotifyObservers)
{
Observable = assessmentSection.ReferenceLine
};
closingStructuresObserver = CreateCalculatableFailureMechanismObserver <ClosingStructuresFailureMechanism,
AdoptableFailureMechanismSectionResult, StructuresCalculation <ClosingStructuresInput> >(assessmentSection.ClosingStructures);
duneErosionObserver = CreateFailureMechanismObserver <DuneErosionFailureMechanism, NonAdoptableFailureMechanismSectionResult>(assessmentSection.DuneErosion);
grassCoverErosionInwardsObserver = CreateCalculatableFailureMechanismObserver <GrassCoverErosionInwardsFailureMechanism,
AdoptableWithProfileProbabilityFailureMechanismSectionResult, GrassCoverErosionInwardsCalculation>(assessmentSection.GrassCoverErosionInwards);
grassCoverErosionOutwardsObserver = CreateFailureMechanismObserver <GrassCoverErosionOutwardsFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.GrassCoverErosionOutwards);
heightStructuresObserver = CreateCalculatableFailureMechanismObserver <HeightStructuresFailureMechanism,
AdoptableFailureMechanismSectionResult, StructuresCalculation <HeightStructuresInput> >(assessmentSection.HeightStructures);
macroStabilityInwardsObserver = CreateCalculatableFailureMechanismObserver <MacroStabilityInwardsFailureMechanism,
AdoptableWithProfileProbabilityFailureMechanismSectionResult, MacroStabilityInwardsCalculationScenario>(assessmentSection.MacroStabilityInwards);
pipingObserver = CreateCalculatableFailureMechanismObserver <PipingFailureMechanism,
AdoptableWithProfileProbabilityFailureMechanismSectionResult, SemiProbabilisticPipingCalculationScenario>(assessmentSection.Piping);
stabilityPointStructuresObserver = CreateCalculatableFailureMechanismObserver <StabilityPointStructuresFailureMechanism,
AdoptableFailureMechanismSectionResult, StructuresCalculation <StabilityPointStructuresInput> >(assessmentSection.StabilityPointStructures);
stabilityStoneCoverObserver = CreateFailureMechanismObserver <StabilityStoneCoverFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.StabilityStoneCover);
waveImpactAsphaltCoverObserver = CreateFailureMechanismObserver <WaveImpactAsphaltCoverFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.WaveImpactAsphaltCover);
grassCoverSlipOffInwardsObserver = CreateFailureMechanismObserver <GrassCoverSlipOffInwardsFailureMechanism,
NonAdoptableFailureMechanismSectionResult>(assessmentSection.GrassCoverSlipOffInwards);
grassCoverSlipOffOutwardsObserver = CreateFailureMechanismObserver <GrassCoverSlipOffOutwardsFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.GrassCoverSlipOffOutwards);
microstabilityObserver = CreateFailureMechanismObserver <MicrostabilityFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.Microstability);
pipingStructureObserver = CreateFailureMechanismObserver <PipingStructureFailureMechanism,
NonAdoptableFailureMechanismSectionResult>(assessmentSection.PipingStructure);
waterPressureAsphaltCoverObserver = CreateFailureMechanismObserver <WaterPressureAsphaltCoverFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(assessmentSection.WaterPressureAsphaltCover);
specificFailureMechanismsObserver = new Observer(() =>
{
ClearSpecificFailureMechanismObservers();
CreateSpecificFailureMechanismObservers();
NotifyObservers();
})
{
Observable = assessmentSection.SpecificFailureMechanisms
};
specificFailureMechanismObservers = new List <Observer>();
CreateSpecificFailureMechanismObservers();
pipingScenarioConfigurationsPerSectionObserver = CreatePipingScenarioConfigurationsPerSectionObserver(assessmentSection.Piping);
}
