avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Cross-section repositort tests

Browse Source
This commit is contained in:
Evgeny Redikultsev
2024-12-07 16:52:18 +05:00
parent 59b989ca89
commit ccaf9a927c
10 changed files with 588 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryCloneStrategy.cs
View File

@@ -3,10 +3,12 @@ using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Parameters;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.Models.Materials.Logics;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.Models.CrossSections
{
@@ -14,129 +16,48 @@ namespace StructureHelperLogics.Models.CrossSections
{
private ICloningStrategy cloningStrategy;
private CrossSectionRepository targetRepository;
private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasHeadMaterials> materialsUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
private IUpdateStrategy<IHasCalculators> calculatorsUpdateStrategy;
public CrossSectionRepositoryCloneStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasHeadMaterials> materialsUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy,
IUpdateStrategy<IHasCalculators> calculatorsUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.materialsUpdateStrategy = materialsUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
this.calculatorsUpdateStrategy = calculatorsUpdateStrategy;
}
public CrossSectionRepositoryCloneStrategy() : this (
new DeepCloningStrategy(),
new LimitCurvesCalculatorInputDataUpdateStrategy())
new HasForceActionUpdateCloningStrategy(null),
new HasMaterialsUpdateCloningStrategy(null),
new HasPrimitivesUpdateCloningStrategy(null),
new HasCalculatorsUpdateCloningStrategy(null))
{
forcesUpdateStrategy = new HasForceActionUpdateCloningStrategy(cloningStrategy);
materialsUpdateStrategy = new HasMaterialsUpdateCloningStrategy(cloningStrategy);
primitivesUpdateStrategy = new HasPrimitivesUpdateCloningStrategy(cloningStrategy);
calculatorsUpdateStrategy = new HasCalculatorsUpdateCloningStrategy(cloningStrategy);
}
public ICrossSectionRepository GetClone(ICrossSectionRepository sourceObject)
{
targetRepository = new();
ProcessForces(targetRepository, sourceObject);
ProcessMaterials(targetRepository, sourceObject);
ProcessPrimitives(targetRepository, sourceObject);
ProcessCalculators(targetRepository, sourceObject);
forcesUpdateStrategy.Update(targetRepository, sourceObject);
materialsUpdateStrategy.Update(targetRepository, sourceObject);
primitivesUpdateStrategy.Update(targetRepository, sourceObject);
calculatorsUpdateStrategy.Update(targetRepository, sourceObject);
return targetRepository;
}
private void ProcessCalculators(IHasCalculators targetObject, IHasCalculators sourceObject)
{
targetObject.Calculators.Clear();
foreach (var calculator in sourceObject.Calculators)
{
var newCalculator = cloningStrategy.Clone(calculator);
if (calculator is IForceCalculator forceCalculator)
{
ProcessForceCalculator(newCalculator, forceCalculator);
}
else if (calculator is CrackCalculator crackCalculator)
{
ProcessCrackCalculator(newCalculator, crackCalculator);
}
else if (calculator is ILimitCurvesCalculator limitCalculator)
{
ProcessLimitCurvesCalculator(newCalculator, limitCalculator);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));
}
targetRepository.Calculators.Add(newCalculator);
}
}
private void ProcessLimitCurvesCalculator(ICalculator newCalculator, ILimitCurvesCalculator limitCalculator)
{
var sourceData = limitCalculator.InputData;
var targetData = ((ILimitCurvesCalculator)newCalculator).InputData;
limitCurvesInputDataUpdateStrategy.Update(targetData, sourceData);
foreach (var series in targetData.PrimitiveSeries)
{
List<INdmPrimitive> collection = UpdatePrimitivesCollection(series);
series.Collection.AddRange(collection);
}
}
private void ProcessCrackCalculator(ICalculator newCalculator, CrackCalculator crackCalculator)
{
var sourceData = crackCalculator.InputData;
var targetData = ((ICrackCalculator)newCalculator).InputData;
ProcessPrimitives(targetData, sourceData);
ProcessForces(targetData, sourceData);
}
private void ProcessForceCalculator(ICalculator newCalculator, IForceCalculator forceCalculator)
{
var sourceData = forceCalculator.InputData;
var targetData = ((IForceCalculator)newCalculator).InputData;
ProcessPrimitives(targetData, sourceData);
ProcessForces(targetData, sourceData);
}
private List<INdmPrimitive> UpdatePrimitivesCollection(NamedCollection<INdmPrimitive> series)
{
List<INdmPrimitive> collection = new();
foreach (var item in series.Collection)
{
var newItem = cloningStrategy.Clone(item);
collection.Add(newItem);
}
series.Collection.Clear();
return collection;
}
private void ProcessMaterials(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject)
{
targetObject.HeadMaterials.Clear();
foreach (var material in sourceObject.HeadMaterials)
{
var newMaterial = cloningStrategy.Clone(material);
targetRepository.HeadMaterials.Add(newMaterial);
}
}
private void ProcessForces(IHasForceActions targetObject, IHasForceActions sourceObject)
{
targetObject.ForceActions.Clear();
foreach (var force in sourceObject.ForceActions)
{
var newForce = cloningStrategy.Clone(force);
targetObject.ForceActions.Add(newForce);
}
}
private void ProcessPrimitives(IHasPrimitives targetObject, IHasPrimitives sourceObject)
{
targetObject.Primitives.Clear();
foreach (var primitive in sourceObject.Primitives)
{
var newPrimitive = cloningStrategy.Clone(primitive);
var material = cloningStrategy.Clone(primitive.NdmElement.HeadMaterial);
newPrimitive.NdmElement.HeadMaterial = material;
targetObject.Primitives.Add(newPrimitive);
}
}
}
}

38
StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,38 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials.Logics
{
/// <summary>
/// Creates deep copy of internal elements of object which has materials
/// </summary>
public class HasMaterialsUpdateCloningStrategy : IUpdateStrategy<IHasHeadMaterials>
{
private ICloningStrategy cloningStrategy;
public HasMaterialsUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
/// <inheritdoc/>
public void Update(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.HeadMaterials.Clear();
foreach (var material in sourceObject.HeadMaterials)
{
var newMaterial = cloningStrategy.Clone(material);
targetObject.HeadMaterials.Add(newMaterial);
}
}
}
}