Add version processor window

StructureHelperLogics/Models/CrossSections/CrossSection.cs

@@ -1,4 +1,5 @@
-using System;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -8,6 +9,7 @@ namespace StructureHelperLogics.Models.CrossSections
 {
     public class CrossSection : ICrossSection
     {
+        private ICloneStrategy<ICrossSection> cloneStrategy = new CrossSectionCloneStrategy();
         public ICrossSectionRepository SectionRepository { get; set; } = new CrossSectionRepository();
 
         public Guid Id { get; private set; }
@@ -24,7 +26,7 @@ namespace StructureHelperLogics.Models.CrossSections
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            return cloneStrategy.GetClone(this);
         }
     }
 }

StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs

@@ -0,0 +1,30 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+
+namespace StructureHelperLogics.Models.CrossSections
+{
+    public class CrossSectionCloneStrategy : ICloneStrategy<ICrossSection>
+    {
+        private ICloneStrategy<ICrossSectionRepository> repositoryCloneStrategy;
+        private CrossSection targetObject;
+
+        public CrossSectionCloneStrategy(ICloneStrategy<ICrossSectionRepository> repositoryCloneStrategy)
+        {
+            this.repositoryCloneStrategy = repositoryCloneStrategy;
+        }
+
+        public CrossSectionCloneStrategy() : this (new CrossSectionRepositoryCloneStrategy())
+        {
+            
+        }
+
+        public ICrossSection GetClone(ICrossSection sourceObject)
+        {
+            ICrossSectionRepository newRepository = repositoryCloneStrategy.GetClone(sourceObject.SectionRepository);
+            targetObject = new()
+            {
+                SectionRepository = newRepository
+            };
+            return targetObject;
+        }
+    }
+}

StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryCloneStrategy.cs

@@ -0,0 +1,142 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Models.Parameters;
+using StructureHelperLogics.Models.Materials;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace StructureHelperLogics.Models.CrossSections
+{
+    public class CrossSectionRepositoryCloneStrategy : ICloneStrategy<ICrossSectionRepository>
+    {
+        private ICloningStrategy cloningStrategy;
+        private CrossSectionRepository targetRepository;
+        private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
+
+        public CrossSectionRepositoryCloneStrategy(
+            ICloningStrategy cloningStrategy,
+            IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
+        {
+            this.cloningStrategy = cloningStrategy;
+            this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
+        }
+
+        public CrossSectionRepositoryCloneStrategy() : this (
+            new DeepCloningStrategy(),
+            new LimitCurvesCalculatorInputDataUpdateStrategy())
+        {
+            
+        }
+
+        public ICrossSectionRepository GetClone(ICrossSectionRepository sourceObject)
+        {
+            targetRepository = new();
+            ProcessForces(targetRepository, sourceObject);
+            ProcessMaterials(targetRepository, sourceObject);
+            ProcessPrimitives(targetRepository, sourceObject);
+            ProcessCalculators(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);
+            }
+        }
+    }
+}