Add Cross-section repositort tests

2024-12-07 16:52:18 +05:00
parent 59b989ca89
commit ccaf9a927c
10 changed files with 588 additions and 107 deletions
--- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
@@ -0,0 +1,114 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Parameters;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Primitives.Logics;
+
+namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
+{
+    /// <summary>
+    /// Creates deep copy of internal elements of object which has calculators
+    /// </summary>
+    public class HasCalculatorsUpdateCloningStrategy : IUpdateStrategy<IHasCalculators>
+    {
+        private ICloningStrategy cloningStrategy;
+        private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
+        private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
+        private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
+
+        public HasCalculatorsUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
+            cloningStrategy,
+            new HasForceActionUpdateCloningStrategy(cloningStrategy),
+            new HasPrimitivesUpdateCloningStrategy(cloningStrategy),
+            new LimitCurvesCalculatorInputDataUpdateStrategy()
+            )
+        {
+        }
+
+        public HasCalculatorsUpdateCloningStrategy(
+            ICloningStrategy cloningStrategy,
+            IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
+            IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy,
+            IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+            this.forcesUpdateStrategy = forcesUpdateStrategy;
+            this.primitivesUpdateStrategy = primitivesUpdateStrategy;
+            this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
+        }
+
+        public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
+        {
+            CheckObject.IsNull(cloningStrategy);
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            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));
+                }
+                targetObject.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;
+            primitivesUpdateStrategy.Update(targetData, sourceData);
+            forcesUpdateStrategy.Update(targetData, sourceData);
+        }
+
+        private void ProcessForceCalculator(ICalculator newCalculator, IForceCalculator forceCalculator)
+        {
+            var sourceData = forceCalculator.InputData;
+            var targetData = ((IForceCalculator)newCalculator).InputData;
+            primitivesUpdateStrategy.Update(targetData, sourceData);
+            forcesUpdateStrategy.Update(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;
+        }
+    }
+}
--- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs
+++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs
@@ -0,0 +1,50 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+
+namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
+{
+    /// <summary>
+    /// Creates deep copy of internal elements of object which has primitives
+    /// </summary>
+    public class HasPrimitivesUpdateCloningStrategy : IUpdateStrategy<IHasPrimitives>
+    {
+        private ICloningStrategy cloningStrategy;
+
+        public HasPrimitivesUpdateCloningStrategy(ICloningStrategy cloningStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+        }
+
+        public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject)
+        {
+            CheckObject.IsNull(cloningStrategy);
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            targetObject.Primitives.Clear();
+            foreach (var primitive in sourceObject.Primitives)
+            {
+                ProcessPrimitive(targetObject, primitive);
+            }
+        }
+
+        private void ProcessPrimitive(IHasPrimitives targetObject, INdmPrimitive primitive)
+        {
+            var newPrimitive = cloningStrategy.Clone(primitive);
+            if (primitive.NdmElement.HeadMaterial is not null)
+            {
+                var material = cloningStrategy.Clone(primitive.NdmElement.HeadMaterial);
+                newPrimitive.NdmElement.HeadMaterial = material;
+            }
+            targetObject.Primitives.Add(newPrimitive);
+            if (primitive is IHasHostPrimitive hasHost)
+            {
+                if (hasHost.HostPrimitive is not null)
+                {
+                    INdmPrimitive hostPrimitive = cloningStrategy.Clone(hasHost.HostPrimitive);
+                    (newPrimitive as IHasHostPrimitive).HostPrimitive = hostPrimitive;
+                }
+            }
+        }
+    }
+}