diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs index e228194..4c088e6 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs @@ -29,9 +29,9 @@ namespace DataAccess.DTOs private void CheckObjects(BeamShearActionDTO source) { - CheckObject.IsNull(source); - CheckObject.IsNull(source.ExternalForce); - CheckObject.IsNull(source.SupportAction); + CheckObject.ThrowIfNull(source); + CheckObject.ThrowIfNull(source.ExternalForce); + CheckObject.ThrowIfNull(source.SupportAction); } private void GetNewAction(BeamShearActionDTO source) diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs index c9a20fb..bf4b0d1 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs @@ -18,9 +18,9 @@ namespace DataAccess.DTOs public override BeamShearAxisAction GetNewItem(BeamShearAxisActionDTO source) { - CheckObject.IsNull(source); - CheckObject.IsNull(source.SupportForce); - CheckObject.IsNull(source.ShearLoads); + CheckObject.ThrowIfNull(source); + CheckObject.ThrowIfNull(source.SupportForce); + CheckObject.ThrowIfNull(source.ShearLoads); InitializeStrategies(); GetNewAction(source); return NewItem; diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs index 1f7a7e1..3dacd93 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs @@ -18,8 +18,8 @@ namespace DataAccess.DTOs public override BeamShearCalculator GetNewItem(BeamShearCalculatorDTO source) { - CheckObject.IsNull(source); - CheckObject.IsNull(source.InputData); + CheckObject.ThrowIfNull(source); + CheckObject.ThrowIfNull(source.InputData); GetNewCalculator(source); return NewItem; } diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs index 9f24310..aee27e1 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs @@ -16,8 +16,8 @@ namespace DataAccess.DTOs public override BeamShear GetNewItem(BeamShearDTO source) { ChildClass = this; - CheckObject.IsNull(source); - CheckObject.IsNull(source.Repository); + CheckObject.ThrowIfNull(source); + CheckObject.ThrowIfNull(source.Repository); GetNewBeamShear(source); return NewItem; } diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs index c92c84f..6a82c2c 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs @@ -13,7 +13,7 @@ namespace DataAccess.DTOs public override IBeamSpanLoad GetNewItem(IBeamSpanLoad source) { - CheckObject.IsNull(source); + CheckObject.ThrowIfNull(source); if (source is DistributedLoadDTO distributed) { ProcessDistributed(distributed); diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs index e7b7d9a..9fd70ab 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs @@ -21,11 +21,11 @@ namespace DataAccess.DTOs public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Actions); - CheckObject.IsNull(targetObject.Actions); + CheckObject.ThrowIfNull(sourceObject.Actions); + CheckObject.ThrowIfNull(targetObject.Actions); targetObject.Actions.Clear(); foreach (var action in sourceObject.Actions) { diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs index 7157445..e4b49e0 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs @@ -18,11 +18,11 @@ namespace DataAccess.DTOs public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Actions); - CheckObject.IsNull(targetObject.Actions); + CheckObject.ThrowIfNull(sourceObject.Actions); + CheckObject.ThrowIfNull(targetObject.Actions); targetObject.Actions.Clear(); foreach (var action in sourceObject.Actions) { diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs index c40bedb..0f4842d 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs @@ -20,11 +20,11 @@ namespace DataAccess.DTOs public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Calculators); - CheckObject.IsNull(targetObject.Calculators); + CheckObject.ThrowIfNull(sourceObject.Calculators); + CheckObject.ThrowIfNull(targetObject.Calculators); targetObject.Calculators.Clear(); List calculators = GetCalculators(sourceObject.Calculators); targetObject.Calculators.AddRange(calculators); diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs index d4872c7..51c92c7 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs @@ -20,11 +20,11 @@ namespace DataAccess.DTOs public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Calculators); - CheckObject.IsNull(targetObject.Calculators); + CheckObject.ThrowIfNull(sourceObject.Calculators); + CheckObject.ThrowIfNull(targetObject.Calculators); targetObject.Calculators.Clear(); List calculators = GetCalculators(sourceObject.Calculators); targetObject.Calculators.AddRange(calculators); diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs index 55e5a3b..fe0d9d0 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs @@ -20,11 +20,11 @@ namespace DataAccess.DTOs public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Sections); - CheckObject.IsNull(targetObject.Sections); + CheckObject.ThrowIfNull(sourceObject.Sections); + CheckObject.ThrowIfNull(targetObject.Sections); targetObject.Sections.Clear(); foreach (var section in sourceObject.Sections) { diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs index 2fdb240..b159a8a 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs @@ -19,11 +19,11 @@ namespace DataAccess.DTOs public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Sections); - CheckObject.IsNull(targetObject.Sections); + CheckObject.ThrowIfNull(sourceObject.Sections); + CheckObject.ThrowIfNull(targetObject.Sections); InitializeStrategies(); targetObject.Sections.Clear(); foreach (var section in sourceObject.Sections) diff --git a/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs index 32f2fe6..67b5651 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs @@ -21,11 +21,11 @@ namespace DataAccess.DTOs public void Update(IHasStirrups targetObject, IHasStirrups sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Stirrups); - CheckObject.IsNull(targetObject.Stirrups); + CheckObject.ThrowIfNull(sourceObject.Stirrups); + CheckObject.ThrowIfNull(targetObject.Stirrups); targetObject.Stirrups.Clear(); List stirrups = GetStirrups(sourceObject.Stirrups); targetObject.Stirrups.AddRange(stirrups); diff --git a/DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs index a6f10c5..8db9df0 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs @@ -21,11 +21,11 @@ namespace DataAccess.DTOs public void Update(IHasStirrups targetObject, IHasStirrups sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Stirrups); - CheckObject.IsNull(targetObject.Stirrups); + CheckObject.ThrowIfNull(sourceObject.Stirrups); + CheckObject.ThrowIfNull(targetObject.Stirrups); targetObject.Stirrups.Clear(); List stirrups = GetStirrups(sourceObject.Stirrups); targetObject.Stirrups.AddRange(stirrups); diff --git a/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs index d08e26f..1d33b61 100644 --- a/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs @@ -43,9 +43,9 @@ namespace DataAccess.DTOs private static void CheckObjects(FactoredForceTupleDTO source) { - CheckObject.IsNull(source); - CheckObject.IsNull(source.ForceTuple); - CheckObject.IsNull(source.CombinationProperty); + CheckObject.ThrowIfNull(source); + CheckObject.ThrowIfNull(source.ForceTuple); + CheckObject.ThrowIfNull(source.CombinationProperty); } private void InitializeStrategies() diff --git a/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs index e2792fd..1dac974 100644 --- a/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs @@ -47,7 +47,7 @@ namespace DataAccess.DTOs private void SetForceTuples(ForceFactoredListDTO source, ForceFactoredList newItem) { - CheckObject.IsNull(newItem.ForceTuples, nameof(newItem.ForceTuples)); + CheckObject.ThrowIfNull(newItem.ForceTuples, nameof(newItem.ForceTuples)); newItem.ForceTuples.Clear(); foreach (var item in source.ForceTuples) { diff --git a/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs index dfadc88..3a540aa 100644 --- a/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs @@ -21,7 +21,7 @@ namespace DataAccess.DTOs public void Update(IHasForceActions targetObject, IHasForceActions sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.ForceActions.Clear(); foreach (var item in sourceObject.ForceActions) diff --git a/DataAccess/DTOs/Converters/HasVisualPropertyFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasVisualPropertyFromDTOUpdateStrategy.cs index 37c180f..e496bd4 100644 --- a/DataAccess/DTOs/Converters/HasVisualPropertyFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/HasVisualPropertyFromDTOUpdateStrategy.cs @@ -20,8 +20,8 @@ namespace DataAccess.DTOs public void Update(IHasVisualProperty targetObject, IHasVisualProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } convertStrategy = new DictionaryConvertStrategy( referenceDictionary, diff --git a/DataAccess/DTOs/Converters/HasVisualPropertyToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasVisualPropertyToDTOUpdateStrategy.cs index 263ff86..e388580 100644 --- a/DataAccess/DTOs/Converters/HasVisualPropertyToDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/HasVisualPropertyToDTOUpdateStrategy.cs @@ -20,8 +20,8 @@ namespace DataAccess.DTOs public void Update(IHasVisualProperty targetObject, IHasVisualProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } convertStrategy = new DictionaryConvertStrategy( referenceDictionary, diff --git a/DataAccess/DTOs/Converters/Materials/HelperMaterialDTOSafetyFactorUpdateStrategy.cs b/DataAccess/DTOs/Converters/Materials/HelperMaterialDTOSafetyFactorUpdateStrategy.cs index 6c99494..abf266f 100644 --- a/DataAccess/DTOs/Converters/Materials/HelperMaterialDTOSafetyFactorUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/Materials/HelperMaterialDTOSafetyFactorUpdateStrategy.cs @@ -28,8 +28,8 @@ namespace DataAccess.DTOs public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } if (sourceObject.SafetyFactors is not null) { diff --git a/DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs index fb3fca4..0ca08b4 100644 --- a/DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs @@ -16,8 +16,8 @@ namespace DataAccess.DTOs /// public void Update(ILibMaterial targetObject, ILibMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } } } diff --git a/DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs index 2126812..6db968d 100644 --- a/DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs @@ -15,7 +15,7 @@ namespace DataAccess.DTOs.Converters public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Primitives.Clear(); foreach (var item in sourceObject.Primitives) diff --git a/DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs index 774ca7e..865d1cc 100644 --- a/DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs @@ -34,9 +34,9 @@ namespace DataAccess.DTOs private static void CheckSourceObject(Point2DRangeDTO source) { - CheckObject.IsNull(source, ": point range source object"); - CheckObject.IsNull(source.StartPoint + ": point range start point"); - CheckObject.IsNull(source.EndPoint + ": point range end point"); + CheckObject.ThrowIfNull(source, ": point range source object"); + CheckObject.ThrowIfNull(source.StartPoint + ": point range start point"); + CheckObject.ThrowIfNull(source.EndPoint + ": point range end point"); } private void InitializeStrategies() diff --git a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs index b0380f7..f4b2b11 100644 --- a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs @@ -27,14 +27,14 @@ namespace DataAccess.DTOs updateStrategy.Update(NewItem, source); ProcessPrimitives(source); ProcessActions(source); - NewItem.Digrams.Clear(); - foreach (var diagram in source.Digrams) + NewItem.Diagrams.Clear(); + foreach (var diagram in source.Diagrams) { if (diagram is not ValueDiagramEntityDTO diagramDTO) { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(diagram)); } - NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagramDTO)); + NewItem.Diagrams.Add(diagramConvertStrategy.Convert(diagramDTO)); } return NewItem; } diff --git a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs index 7a64b83..861600a 100644 --- a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs @@ -28,10 +28,10 @@ namespace DataAccess.DTOs updateStrategy.Update(NewItem, source); ProcessPrimitives(source); ProcessActions(source); - NewItem.Digrams.Clear(); - foreach (var diagram in source.Digrams) + NewItem.Diagrams.Clear(); + foreach (var diagram in source.Diagrams) { - NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagram)); + NewItem.Diagrams.Add(diagramConvertStrategy.Convert(diagram)); } return NewItem; } diff --git a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs index 9474ac3..b06ff13 100644 --- a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs @@ -19,11 +19,11 @@ namespace DataAccess.DTOs NewItem = new(source.Id); InitializeStrategies(); updateStrategy.Update(NewItem, source); - if (source.ValueDigram is not ValueDiagramDTO diagramDTO) + if (source.ValueDiagram is not ValueDiagramDTO diagramDTO) { - throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDigram)); + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDiagram)); } - NewItem.ValueDigram = diagramConvertStrategy.Convert(diagramDTO); + NewItem.ValueDiagram = diagramConvertStrategy.Convert(diagramDTO); return NewItem; } diff --git a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs index 193aee0..2bad464 100644 --- a/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs @@ -18,7 +18,7 @@ namespace DataAccess.DTOs NewItem = new(source.Id); InitializeStrategies(); updateStrategy.Update(NewItem, source); - NewItem.ValueDigram = diagramConvertStrategy.Convert(source.ValueDigram); + NewItem.ValueDiagram = diagramConvertStrategy.Convert(source.ValueDiagram); return NewItem; } diff --git a/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs index 98dbd75..dc226ff 100644 --- a/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs @@ -13,7 +13,7 @@ namespace DataAccess.DTOs [JsonProperty("StateTermPair")] public IStateCalcTermPair StateTermPair { get; set; } = new StateCalcTermPairDTO(); [JsonProperty("Diagrams")] - public List Digrams { get; } = []; + public List Diagrams { get; } = []; [JsonProperty("CheckStrainLimits")] public bool CheckStrainLimit { get; set; } = true; [JsonProperty("ForceActions")] diff --git a/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs b/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs index 9cf627b..75f8c50 100644 --- a/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs @@ -12,7 +12,7 @@ namespace DataAccess.DTOs [JsonProperty("IsTaken")] public bool IsTaken { get; set; } [JsonProperty("ValueDiagram")] - public IValueDiagram ValueDigram { get; set; } + public IValueDiagram ValueDiagram { get; set; } public ValueDiagramEntityDTO(Guid id) diff --git a/StructureHelper/Documentation/Examples/ValueDiagrams.shpj b/StructureHelper/Documentation/Examples/ValueDiagrams.shpj new file mode 100644 index 0000000..f989630 --- /dev/null +++ b/StructureHelper/Documentation/Examples/ValueDiagrams.shpj @@ -0,0 +1,1084 @@ +{ + "$id": "1", + "$type": "RootObject", + "FileVersion": { + "Id": "e18f050f-e85a-4ceb-90b6-b5cee389e4a6", + "VersionNumber": 1, + "SubVersionNumber": 4 + }, + "Project": { + "Id": "3261d1f4-a976-45f1-a17a-46174730d6f1", + "VisualAnalyses": { + "$id": "2", + "$type": "ListOfIVisualAnalysis", + "$values": [ + { + "$id": "3", + "$type": "VisualAnalysis", + "Id": "7911a244-8ce2-42d1-8e6a-3a8bd147db0d", + "Analysis": { + "$id": "4", + "$type": "CrossSectionNdmAnalysis", + "Id": "0f3a7ada-3b11-4cbe-96b1-0285805a11b6", + "Name": "New NDM Analysis", + "Tags": "#New group", + "VersionProcessor": { + "$id": "5", + "$type": "VersionProcessor", + "Id": "faaec0bc-2da0-4af8-8e02-b0ec78c44b0d", + "Versions": { + "$type": "ListOfIDateVersion", + "$values": [ + { + "$id": "6", + "$type": "DateVersion", + "Id": "d6459e23-174c-4aa1-84fc-e9e7623d391b", + "DateTime": "2025-11-16T14:25:06.9693914+05:00", + "Comment": "", + "AnalysisVersion": { + "$id": "7", + "$type": "CrossSection", + "Id": "31a2ade6-d9ff-4cb0-888c-889b0304ae6e", + "SectionRepository": { + "$id": "8", + "$type": "CrossSectionRepository", + "Id": "7d24cdf5-ee5a-4507-a11b-86ffecf9828b", + "HeadMaterials": { + "$type": "ListOfIHeadMaterial", + "$values": [ + { + "$id": "9", + "$type": "HeadMaterial", + "Id": "d581c9a3-3731-4a58-bdc5-a40a39a0c908", + "Name": "Concrete", + "Color": "#FFF0F8FF", + "HelperMaterial": { + "$id": "10", + "$type": "ConcreteLibMaterial", + "Id": "493e1d56-34c6-4ed1-99de-1a14ce35aadc", + "RelativeHumidity": 0.55, + "MinAge": 0.0, + "MaxAge": 2207520000.0, + "MaterialEntityId": "32614a91-fc85-4690-aa82-af45e00f7638", + "SafetyFactors": { + "$id": "11", + "$type": "ListOfMaterialSafetyFactor", + "$values": [ + { + "$id": "12", + "$type": "MaterialSafetyFactor", + "Id": "9952731e-393c-494e-98ee-7a7c2994024b", + "Name": "Gamma_b1", + "Take": true, + "Description": "Coefficient for considering long term calculations", + "PartialFactors": { + "$type": "ListOfMaterialPartialFactor", + "$values": [ + { + "$id": "13", + "$type": "MaterialPartialFactor", + "Id": "6af09ad6-02c5-4574-9273-1f1e4bc11729", + "FactorValue": 0.9, + "StressState": 0, + "CalcTerm": 2, + "LimitState": 1 + }, + { + "$id": "14", + "$type": "MaterialPartialFactor", + "Id": "a6aaff05-6f22-40c4-af35-8bbaf27dc7f8", + "FactorValue": 0.9, + "StressState": 1, + "CalcTerm": 2, + "LimitState": 1 + } + ] + } + }, + { + "$id": "15", + "$type": "MaterialSafetyFactor", + "Id": "122a1824-5801-4f2f-be0e-2d23c37d57d7", + "Name": "Gamma_b2", + "Take": false, + "Description": "Coefficient for plain concrete structures", + "PartialFactors": { + "$type": "ListOfMaterialPartialFactor", + "$values": [ + { + "$id": "16", + "$type": "MaterialPartialFactor", + "Id": "fd3ddbae-d793-40fa-85b7-b919f8f0a572", + "FactorValue": 0.9, + "StressState": 1, + "CalcTerm": 1, + "LimitState": 1 + }, + { + "$id": "17", + "$type": "MaterialPartialFactor", + "Id": "a76aa5bc-13d5-42a0-b790-97a61ecff73c", + "FactorValue": 0.9, + "StressState": 1, + "CalcTerm": 2, + "LimitState": 1 + } + ] + } + }, + { + "$id": "18", + "$type": "MaterialSafetyFactor", + "Id": "dcfa829c-a9ca-41c9-855f-219c9a34e9fe", + "Name": "Gamma_b3", + "Take": false, + "Description": "Coefficient for considering bleeding in vertical placement conditionals", + "PartialFactors": { + "$type": "ListOfMaterialPartialFactor", + "$values": [ + { + "$id": "19", + "$type": "MaterialPartialFactor", + "Id": "8b68b30c-3739-42ec-a0e1-dc6d4b4f5e49", + "FactorValue": 0.85, + "StressState": 1, + "CalcTerm": 1, + "LimitState": 1 + }, + { + "$id": "20", + "$type": "MaterialPartialFactor", + "Id": "1961ceb0-d2f5-4346-8a98-b3c5a3675e5b", + "FactorValue": 0.85, + "StressState": 1, + "CalcTerm": 2, + "LimitState": 1 + } + ] + } + } + ] + }, + "TensionForULS": false, + "TensionForSLS": true, + "MaterialLogicId": "b97e8168-76a1-4e24-ae98-9aa38edd1e9a" + } + }, + { + "$id": "21", + "$type": "HeadMaterial", + "Id": "d49275e5-42bc-4bb3-a2d7-cf787671e85c", + "Name": "Reinforcement", + "Color": "#FFFF0000", + "HelperMaterial": { + "$id": "22", + "$type": "ReinforcementLibMaterial", + "Id": "7a0f25a9-b402-45cf-9d85-3dfdf639ffec", + "MaterialEntityId": "ea422282-3465-433c-9b93-c5bbfba5a904", + "SafetyFactors": { + "$id": "23", + "$type": "ListOfMaterialSafetyFactor", + "$values": [] + }, + "MaterialLogicId": "54c4fe40-8f82-4995-8930-81e65e97edb9" + } + } + ] + }, + "ForceActions": { + "$type": "ListOfIForceAction", + "$values": [ + { + "$id": "24", + "$type": "ForceCombinationByFactor_v1_1", + "Id": "585a6086-7487-4a48-9d9e-39af1eb5008c", + "Name": "New Factored Load", + "ForceTuples": { + "$type": "ListOfIForceTuple", + "$values": [ + { + "$id": "25", + "$type": "ForceTuple", + "Id": "3a6481fc-db56-4ff4-ade5-58aba17ee577", + "Mx": -60000.0, + "My": -60000.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + ] + }, + "SetInGravityCenter": true, + "ForcePoint": { + "$id": "26", + "$type": "Point2D", + "Id": "478fc083-40a2-433a-884f-12a94e61fa50", + "X": 0.0, + "Y": 0.0 + }, + "CombinationProperty": { + "$id": "27", + "$type": "ForceFactoredCombinationProperty", + "Id": "7de9dca0-4680-4b92-b9f2-d02942efcd47", + "CalctTerm": 1, + "LimitState": 2, + "LongTermFactor": 1.0, + "ULSFactor": 1.2 + } + }, + { + "$id": "28", + "$type": "ForceCombinationByFactor_v1_1", + "Id": "27baa168-6c84-4fca-8c8e-898e9be9a009", + "Name": "New Factored Load copy", + "ForceTuples": { + "$type": "ListOfIForceTuple", + "$values": [ + { + "$id": "29", + "$type": "ForceTuple", + "Id": "96e80328-98b6-4a7e-bd40-0ab3cb7e8203", + "Mx": -120000.0, + "My": -120000.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + ] + }, + "SetInGravityCenter": true, + "ForcePoint": { + "$id": "30", + "$type": "Point2D", + "Id": "d8912037-f3cb-46e5-b685-88af069b20b1", + "X": 0.0, + "Y": 0.0 + }, + "CombinationProperty": { + "$id": "31", + "$type": "ForceFactoredCombinationProperty", + "Id": "5389d3bf-86ef-4c73-9c51-9209d6587556", + "CalctTerm": 1, + "LimitState": 2, + "LongTermFactor": 1.0, + "ULSFactor": 1.2 + } + }, + { + "$id": "32", + "$type": "ForceCombinationByFactor_v1_1", + "Id": "9f182923-6863-4b3a-887d-a2cb94a79fd2", + "Name": "New Factored Load copy copy", + "ForceTuples": { + "$type": "ListOfIForceTuple", + "$values": [ + { + "$id": "33", + "$type": "ForceTuple", + "Id": "23635866-6046-4c81-86fd-d5a45e85f05d", + "Mx": -180000.0, + "My": -180000.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + ] + }, + "SetInGravityCenter": true, + "ForcePoint": { + "$id": "34", + "$type": "Point2D", + "Id": "23366456-6815-4bb0-ae9c-d5f9b7e96462", + "X": 0.0, + "Y": 0.0 + }, + "CombinationProperty": { + "$id": "35", + "$type": "ForceFactoredCombinationProperty", + "Id": "ce5af934-2498-4e8a-8caf-0ca8ab6c4b8c", + "CalctTerm": 1, + "LimitState": 2, + "LongTermFactor": 1.0, + "ULSFactor": 1.2 + } + }, + { + "$id": "36", + "$type": "ForceCombinationByFactor_v1_1", + "Id": "fc4e1009-28af-45ee-9976-c03a3d4dcc02", + "Name": "New Factored Load copy copy copy", + "ForceTuples": { + "$type": "ListOfIForceTuple", + "$values": [ + { + "$id": "37", + "$type": "ForceTuple", + "Id": "500de536-8865-487c-b41e-7b3e20099fc7", + "Mx": -240000.0, + "My": -240000.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + ] + }, + "SetInGravityCenter": true, + "ForcePoint": { + "$id": "38", + "$type": "Point2D", + "Id": "9af4aa60-dd39-4cc0-9dff-5b285694acdc", + "X": 0.0, + "Y": 0.0 + }, + "CombinationProperty": { + "$id": "39", + "$type": "ForceFactoredCombinationProperty", + "Id": "1625f23b-19ea-45ce-99ab-687e5011814d", + "CalctTerm": 1, + "LimitState": 2, + "LongTermFactor": 1.0, + "ULSFactor": 1.2 + } + } + ] + }, + "Primitives": { + "$type": "ListOfINdmPrimitive", + "$values": [ + { + "$id": "40", + "$type": "RectangleNdmPrimitive", + "Id": "e8798eea-b95c-493b-a46a-c3c5174a054c", + "Name": "Concrete block", + "RectangleShape": { + "$id": "41", + "$type": "RectangleShape", + "Id": "03b4eb9a-b531-4238-93b2-537358ce7710", + "Width": 0.5, + "Height": 0.5 + }, + "NdmElement": { + "$id": "42", + "$type": "NdmElement", + "Id": "e7fde32d-db22-41fb-b7c7-c9297f68d7d6", + "HeadMaterial": { + "$ref": "9" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "43", + "$type": "ForceTuple", + "Id": "40a79af8-8bc1-4e15-b66d-8832206ce061", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "44", + "$type": "VisualProperty", + "Id": "c9ee4dfa-6419-492d-8cf1-ec955a40d28f", + "IsVisible": true, + "Color": "#FFFDC99F", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 0.8 + }, + "Center": { + "$id": "45", + "$type": "Point2D", + "Id": "553768e6-5b6c-4d67-bc6f-f9daf9f3aa55", + "X": 0.0, + "Y": 0.0 + }, + "DivisionSize": { + "$id": "46", + "$type": "DivisionSize", + "Id": "67482c21-928a-4eb2-bcba-064120c53715", + "NdmMaxSize": 0.01, + "NdmMinDivision": 10, + "ClearUnderlying": false + }, + "RotationAngle": 0.0 + }, + { + "$id": "47", + "$type": "RebarNdmPrimitive", + "Id": "b48ac75d-2002-43ab-8ece-df8b9a255b64", + "Name": "Left bottom rebar", + "NdmElement": { + "$id": "48", + "$type": "NdmElement", + "Id": "29d0b735-4335-4f3e-b1ad-83a3ea5c7710", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "49", + "$type": "ForceTuple", + "Id": "83cff6f8-7c9f-4aed-a8a2-ae20fb5b7678", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "50", + "$type": "VisualProperty", + "Id": "8f91b5fd-18f2-4546-9c26-56f9a4054178", + "IsVisible": true, + "Color": "#FF9F1B45", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "51", + "$type": "Point2D", + "Id": "ffba0d5e-81a8-4d45-afd9-5ed7b6d78e84", + "X": -0.2, + "Y": -0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "52", + "$type": "RebarNdmPrimitive", + "Id": "6fc9fc17-339b-4c9c-a991-df005fbce3d1", + "Name": "Right bottom rebar", + "NdmElement": { + "$id": "53", + "$type": "NdmElement", + "Id": "aa466813-c42f-4bae-9ead-f00adbd5efa1", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "54", + "$type": "ForceTuple", + "Id": "a81364d6-4608-4205-ad5a-3f09779be02e", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "55", + "$type": "VisualProperty", + "Id": "a9da6cfa-a7b8-4436-841a-b01eeb3f5294", + "IsVisible": true, + "Color": "#FF9F3806", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "56", + "$type": "Point2D", + "Id": "8ce34fba-5e0e-481f-ab22-2f3c9613ad2c", + "X": 0.2, + "Y": -0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "57", + "$type": "RebarNdmPrimitive", + "Id": "0bb528c5-aa6c-4a2f-9660-71604392a9c8", + "Name": "Left top rebar", + "NdmElement": { + "$id": "58", + "$type": "NdmElement", + "Id": "99967c90-dbc5-4755-a0fe-055a9c7084ac", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "59", + "$type": "ForceTuple", + "Id": "67970826-53bd-4e8a-9889-67d3066bd3d7", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "60", + "$type": "VisualProperty", + "Id": "970ee415-cd4d-43d9-8e9a-02ea7bb2e040", + "IsVisible": true, + "Color": "#FF0DF6D2", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "61", + "$type": "Point2D", + "Id": "b61e6b44-e191-477d-8610-0b11be0dacc5", + "X": -0.2, + "Y": 0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "62", + "$type": "RebarNdmPrimitive", + "Id": "5d4bb1e0-c539-4367-ad5e-39b212aefe83", + "Name": "Right top rebar", + "NdmElement": { + "$id": "63", + "$type": "NdmElement", + "Id": "b19844a9-756f-4ea1-984f-ea7d23d8dbfe", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "64", + "$type": "ForceTuple", + "Id": "5f3668e2-b300-432e-a98e-4677752a91bc", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "65", + "$type": "VisualProperty", + "Id": "8ee9a2f7-0df6-4c7f-ac69-302edfc02ffb", + "IsVisible": true, + "Color": "#FF4CF72D", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "66", + "$type": "Point2D", + "Id": "dccb0b3b-e6b4-43a7-8321-1072fa203ba7", + "X": 0.2, + "Y": 0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "67", + "$type": "RebarNdmPrimitive", + "Id": "15eb442a-33d4-4d37-a82c-0232c81a191a", + "Name": "Bottom rebar 1", + "NdmElement": { + "$id": "68", + "$type": "NdmElement", + "Id": "8e8a6d13-0c88-4dd9-8cd7-20e18463dff2", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "69", + "$type": "ForceTuple", + "Id": "671e3605-1673-4add-b24d-de7f96610e0a", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "70", + "$type": "VisualProperty", + "Id": "844decf0-f532-492e-bbe1-e04d286eb2d1", + "IsVisible": true, + "Color": "#FF027D55", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "71", + "$type": "Point2D", + "Id": "52aca2f2-88e3-41af-a2a0-431eaee8371c", + "X": 0.0, + "Y": -0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "72", + "$type": "RebarNdmPrimitive", + "Id": "74a6baed-3694-43da-8f08-5426bb2dce97", + "Name": "Top rebar 1", + "NdmElement": { + "$id": "73", + "$type": "NdmElement", + "Id": "13a308e2-20ce-4621-a378-e807dda90987", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "74", + "$type": "ForceTuple", + "Id": "10d3ede1-e7c4-42cb-a4f4-ae2e2d24dfa7", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "75", + "$type": "VisualProperty", + "Id": "22f0b643-8c3f-41d9-a891-de511a281a24", + "IsVisible": true, + "Color": "#FF194495", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "76", + "$type": "Point2D", + "Id": "369ef26b-96d3-4f30-b7c8-daba600deaec", + "X": 0.0, + "Y": 0.2 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "77", + "$type": "RebarNdmPrimitive", + "Id": "7917ab37-7f16-474a-9984-7ce7179c2e7b", + "Name": "Left point 1", + "NdmElement": { + "$id": "78", + "$type": "NdmElement", + "Id": "d0cd32b5-ec1f-44a1-b83c-c05be9cb3b2c", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "79", + "$type": "ForceTuple", + "Id": "e0bc38ef-1651-411a-bd96-7db1e0f4ae69", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "80", + "$type": "VisualProperty", + "Id": "39631369-2a29-4531-9fc7-2e01a9db23c0", + "IsVisible": true, + "Color": "#FFEDB24D", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "81", + "$type": "Point2D", + "Id": "62eb5e35-52ef-4bd1-bc61-5985b3cac7a5", + "X": -0.2, + "Y": 0.0 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + }, + { + "$id": "82", + "$type": "RebarNdmPrimitive", + "Id": "365e0a21-58fe-4cdb-b77b-6f3072bfd047", + "Name": "Right point 1", + "NdmElement": { + "$id": "83", + "$type": "NdmElement", + "Id": "9cb98b36-e216-4613-9bdc-77358cbab2b7", + "HeadMaterial": { + "$ref": "21" + }, + "Triangulate": true, + "UsersPrestrain": { + "$id": "84", + "$type": "ForceTuple", + "Id": "589044d7-4e14-4335-b04b-9b3143e4aff6", + "Mx": 0.0, + "My": 0.0, + "Nz": 0.0, + "Qx": 0.0, + "Qy": 0.0, + "Mz": 0.0 + } + }, + "VisualProperty": { + "$id": "85", + "$type": "VisualProperty", + "Id": "b27d6a93-1776-48ab-8e5a-c8d8e24a5bc7", + "IsVisible": true, + "Color": "#FFEE2390", + "SetMaterialColor": true, + "ZIndex": 0, + "Opacity": 1.0 + }, + "Center": { + "$id": "86", + "$type": "Point2D", + "Id": "f41b8dce-4586-4f07-8086-64d8ecb8a6e3", + "X": 0.2, + "Y": 0.0 + }, + "RotationAngle": 0.0, + "Area": 0.0004908738521234052, + "HostPrimitive": { + "$ref": "40" + } + } + ] + }, + "Calculators": { + "$type": "ListOfICalculator", + "$values": [ + { + "$id": "87", + "$type": "ForceCalculator", + "Id": "f384af28-aad0-4742-85b4-1daada96fbde", + "Name": "New Force Calculator", + "ShowTraceData": false, + "InputData": { + "$id": "88", + "$type": "ForceCalculatorInputData", + "Id": "8bea9b17-6ad8-40ae-9644-911809f01cd3", + "ForceActions": { + "$id": "89", + "$type": "ListOfIForceAction", + "$values": [ + { + "$ref": "24" + } + ] + }, + "Primitives": { + "$id": "90", + "$type": "ListOfINdmPrimitive", + "$values": [ + { + "$ref": "40" + }, + { + "$ref": "47" + }, + { + "$ref": "52" + }, + { + "$ref": "57" + }, + { + "$ref": "62" + }, + { + "$ref": "67" + }, + { + "$ref": "72" + }, + { + "$ref": "77" + }, + { + "$ref": "82" + } + ] + }, + "LimitStatesList": { + "$id": "91", + "$type": "ListOfLimitState", + "$values": [ + 1, + 2 + ] + }, + "CalcTermList": { + "$id": "92", + "$type": "ListOfCalcTerms", + "$values": [ + 1, + 2 + ] + }, + "Accuracy": { + "$id": "93", + "$type": "Accuracy", + "Id": "3a3fd952-6728-4837-b419-fbbc673af383", + "IterationAccuracy": 0.001, + "MaxIterationCount": 1000 + }, + "CompressedMember": { + "$id": "94", + "$type": "CompressedMember", + "Id": "f78e3391-48b6-4bff-91f7-21bc2f79530a", + "Bucling": false, + "GeometryLength": 3.0, + "LengthFactorX": 1.0, + "DiagramFactorX": 1.0, + "LengthFactorY": 1.0, + "DiagramFactorY": 1.0 + }, + "CheckStrainLimit": true + } + }, + { + "$id": "95", + "$type": "CrackCalculator", + "Id": "7f5fa610-dcee-4add-bef4-3d2c311b25d7", + "Name": "New Crack Calculator", + "ShowTraceData": false, + "InputData": { + "$id": "96", + "$type": "CrackCalculatorInputData", + "Id": "85e1acf8-3790-40ba-b1a2-6ed9ae0a95d9", + "ForceActions": { + "$id": "97", + "$type": "ListOfIForceAction", + "$values": [ + { + "$ref": "24" + } + ] + }, + "ForcePrimitives": { + "$id": "98", + "$type": "ListOfINdmPrimitive", + "$values": [ + { + "$ref": "40" + }, + { + "$ref": "47" + }, + { + "$ref": "52" + }, + { + "$ref": "57" + }, + { + "$ref": "62" + }, + { + "$ref": "67" + }, + { + "$ref": "72" + }, + { + "$ref": "77" + }, + { + "$ref": "82" + } + ] + }, + "UserCrackInputData": { + "$id": "99", + "$type": "UserCrackInputData", + "Id": "1b395d98-31be-45b7-bff1-3af8267dc8a3", + "LengthBetweenCracks": 0.4, + "SetLengthBetweenCracks": true, + "SetSofteningFactors": true, + "SofteningFactors": 1.0, + "UltimateLongCrackWidths": 0.0003, + "UltimateShortCrackWidths": 0.0004 + } + } + }, + { + "$id": "100", + "$type": "ValueDiagramCalculator", + "Id": "1eae2bf9-a96d-4bea-bdbd-5239ed5b7abd", + "Name": "New value diagram calcualtor", + "InputData": { + "$id": "101", + "$type": "ValueDiagramCalculatorInputData", + "Id": "a24e18f2-5900-484d-91a7-e65ea2b537ba", + "StateTermPair": { + "$id": "102", + "$type": "StateCalcTermPair", + "LimitState": 2, + "CalcTerm": 1 + }, + "Diagrams": { + "$type": "ListOfValueDiagramEntity", + "$values": [ + { + "$id": "103", + "$type": "ValueDiagramEntity", + "Id": "cd2a05b0-83e9-4640-8da8-0582ba343a77", + "Name": "New diagram", + "IsTaken": true, + "ValueDiagram": { + "$id": "104", + "$type": "ValueDiagram", + "Id": "ea04a8a1-afb1-4645-b7ff-71c5917d3fa2", + "Point2DRange": { + "$id": "105", + "$type": "Point2DRange", + "Id": "2a8e4945-1258-49fe-8276-ea18908101dd", + "StartPoint": { + "$id": "106", + "$type": "Point2D", + "Id": "2e65736b-b564-410f-8514-56ee64fa4898", + "X": -0.25, + "Y": 0.25 + }, + "EndPoint": { + "$id": "107", + "$type": "Point2D", + "Id": "41338bec-72d2-471c-a08b-9f4effa2c9b0", + "X": 0.25, + "Y": -0.25 + } + }, + "StepNumber": 50 + } + } + ] + }, + "CheckStrainLimits": true, + "ForceActions": { + "$type": "ListOfIForceAction", + "$values": [ + { + "$ref": "24" + }, + { + "$ref": "28" + }, + { + "$ref": "32" + }, + { + "$ref": "36" + } + ] + }, + "Primitives": { + "$type": "ListOfINdmPrimitive", + "$values": [ + { + "$ref": "40" + }, + { + "$ref": "47" + }, + { + "$ref": "52" + }, + { + "$ref": "57" + }, + { + "$ref": "62" + }, + { + "$ref": "67" + }, + { + "$ref": "72" + }, + { + "$ref": "77" + }, + { + "$ref": "82" + } + ] + } + }, + "ShowTraceData": false + } + ] + } + }, + "WorkPlaneProperty": { + "$id": "108", + "$type": "WorkPlanePropertyDTO", + "Id": "58e44c10-26e0-413b-a3d6-2b828f6ddc74", + "GridSize": 0.05, + "Width": 1.2, + "Height": 1.2, + "AxisLineThickness": 2.0, + "GridLineThickness": 0.25 + } + } + } + ] + } + }, + "Comment": "", + "Color": "#FF800000" + } + } + ] + } + } +} \ No newline at end of file diff --git a/StructureHelper/Documentation/Manuals/Руководство пользователя.docx b/StructureHelper/Documentation/Manuals/Руководство пользователя.docx index 4097deb..80bbffc 100644 Binary files a/StructureHelper/Documentation/Manuals/Руководство пользователя.docx and b/StructureHelper/Documentation/Manuals/Руководство пользователя.docx differ diff --git a/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml b/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml index 5dd9a5a..697477b 100644 --- a/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml +++ b/StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml @@ -37,10 +37,22 @@ - - + + diff --git a/StructureHelper/Properties/AssemblyInfo.cs b/StructureHelper/Properties/AssemblyInfo.cs index 8f94f98..f4cce35 100644 --- a/StructureHelper/Properties/AssemblyInfo.cs +++ b/StructureHelper/Properties/AssemblyInfo.cs @@ -49,5 +49,5 @@ using System.Windows; // Можно задать все значения или принять номера сборки и редакции по умолчанию // используя "*", как показано ниже: // [assembly: AssemblyVersion("1.0.*")] -[assembly: AssemblyVersion("2025.07.23.01")] -[assembly: AssemblyFileVersion("2025.07.23.01")] +[assembly: AssemblyVersion("2025.11.17.01")] +[assembly: AssemblyFileVersion("2025.11.17.01")] diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs index 7e8dddc..ded27c7 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs @@ -32,7 +32,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr this.inputData = inputData; this.repository = repository; StateCalcTermPairViewModel = new(inputData.StateTermPair); - ValueDiagramsViewModel = new(inputData.Digrams); + ValueDiagramsViewModel = new(inputData.Diagrams); CombinationViewModel = SourceTargetFactory.GetSourceTargetVM(repository.ForceActions, inputData.ForceActions); PrimitivesViewModel = SourceTargetFactory.GetSourceTargetVM(repository.Primitives, inputData.Primitives); } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityViewModel.cs index 35791e3..c591160 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityViewModel.cs @@ -31,7 +31,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr public ValueDiagramEntityViewModel(IValueDiagramEntity valueDiagramEntity) { this.valueDiagramEntity = valueDiagramEntity; - ValueDiagram = new(valueDiagramEntity.ValueDigram); + ValueDiagram = new(valueDiagramEntity.ValueDiagram); } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramsViewModel.cs index 78b1888..b1ba1dd 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramsViewModel.cs @@ -19,9 +19,9 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr IsTaken = true, Name = "New Value Diagram" }; - NewItem.ValueDigram.StepNumber = 50; - NewItem.ValueDigram.Point2DRange.StartPoint.Y = 0.25; - NewItem.ValueDigram.Point2DRange.EndPoint.Y = - 0.25; + NewItem.ValueDiagram.StepNumber = 50; + NewItem.ValueDiagram.Point2DRange.StartPoint.Y = 0.25; + NewItem.ValueDiagram.Point2DRange.EndPoint.Y = - 0.25; base.AddMethod(parameter); } public override void EditMethod(object parameter) diff --git a/StructureHelper/Windows/Graphs/GraphView.xaml b/StructureHelper/Windows/Graphs/GraphView.xaml index 66475e5..d6fe878 100644 --- a/StructureHelper/Windows/Graphs/GraphView.xaml +++ b/StructureHelper/Windows/Graphs/GraphView.xaml @@ -8,7 +8,7 @@ xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls" d:DataContext="{d:DesignInstance local:GraphViewModel}" mc:Ignorable="d" - Title="Graph" Height="650" Width="1000" MinHeight="500" MinWidth="600" MaxHeight="1100" MaxWidth="1800" WindowStartupLocation="CenterScreen"> + Title="Graph" Height="750" Width="1200" MinHeight="500" MinWidth="600" MaxHeight="1100" MaxWidth="1800" WindowStartupLocation="CenterScreen"> @@ -57,7 +57,7 @@ - + diff --git a/StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs b/StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs index 88a3f66..d425cbe 100644 --- a/StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs +++ b/StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs @@ -83,7 +83,8 @@ namespace StructureHelper.Windows.MainWindow.CrossSections } } - data[pointPrimitives.Count, 0] = GetDistance(startPoint, endPoint); + double fullLength = GetDistance(startPoint, endPoint); + data[pointPrimitives.Count, 0] = fullLength; data[pointPrimitives.Count, 1] = endPoint.X; data[pointPrimitives.Count, 2] = endPoint.Y; @@ -91,7 +92,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections data[pointPrimitives.Count + 1, 1] = startPoint.X; data[pointPrimitives.Count + 1, 2] = startPoint.Y; - data[pointPrimitives.Count, 0] = 0.0; + data[pointPrimitives.Count + 2, 0] = 0.0; data[pointPrimitives.Count + 2, 1] = startPoint.X; data[pointPrimitives.Count + 2, 2] = startPoint.Y; for (int j = 0; j < resultFuncs.Count; j++) diff --git a/StructureHelper/Windows/PrimitivePropertiesWindow/SelectPrimitivesView.xaml b/StructureHelper/Windows/PrimitivePropertiesWindow/SelectPrimitivesView.xaml index 2de2acb..52e42ba 100644 --- a/StructureHelper/Windows/PrimitivePropertiesWindow/SelectPrimitivesView.xaml +++ b/StructureHelper/Windows/PrimitivePropertiesWindow/SelectPrimitivesView.xaml @@ -13,6 +13,7 @@ + diff --git a/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs index fdeaa0d..77095a5 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs @@ -12,7 +12,7 @@ namespace StructureHelperCommon.Infrastructures.Interfaces public abstract void Update(T targetObject, T sourceObject); public void Check(T targetObject, T sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; } } diff --git a/StructureHelperCommon/Infrastructures/Interfaces/CheckEntityLogic.cs b/StructureHelperCommon/Infrastructures/Interfaces/CheckEntityLogic.cs new file mode 100644 index 0000000..ea0984e --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/CheckEntityLogic.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Models; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public abstract class CheckEntityLogic : ICheckEntityLogic where TEntity : class + { + public TEntity Entity { get; set; } + + public virtual string CheckResult { get; set; } = string.Empty; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public abstract bool Check(); + + public virtual void TraceMessage(string errorString) + { + CheckResult += errorString + "\n"; + TraceLogger?.AddMessage(errorString); + } + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs index 4f66ed3..64c69a8 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs @@ -21,9 +21,9 @@ namespace StructureHelperCommon.Infrastructures.Interfaces public void Update(IHasForceActions targetObject, IHasForceActions sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.ForceActions.Clear(); foreach (var force in sourceObject.ForceActions) diff --git a/StructureHelperCommon/Models/Analyses/AnalysisUpdateStrategy.cs b/StructureHelperCommon/Models/Analyses/AnalysisUpdateStrategy.cs index bfca454..d560660 100644 --- a/StructureHelperCommon/Models/Analyses/AnalysisUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Analyses/AnalysisUpdateStrategy.cs @@ -12,7 +12,7 @@ namespace StructureHelperCommon.Models.Analyses { public void Update(IAnalysis targetObject, IAnalysis sourceObject) { - CheckObject.IsNull(targetObject, sourceObject, "Analysis Properties"); + CheckObject.ThrowIfNull(targetObject, sourceObject, "Analysis Properties"); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.Tags = sourceObject.Tags; diff --git a/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs b/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs index 9a29d46..11d1403 100644 --- a/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Analyses { public void Update(IDateVersion targetObject, IDateVersion sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.DateTime = sourceObject.DateTime; } diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs index b49a546..62ddfba 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs @@ -8,14 +8,14 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy axisActionUpdateStrategy; public void Update(IBeamShearAction targetObject, IBeamShearAction sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.ExternalForce = sourceObject.ExternalForce.Clone() as IFactoredForceTuple; InitializeStrategies(); - CheckObject.IsNull(sourceObject.SupportAction); - CheckObject.IsNull(targetObject.SupportAction); + CheckObject.ThrowIfNull(sourceObject.SupportAction); + CheckObject.ThrowIfNull(targetObject.SupportAction); axisActionUpdateStrategy.Update(targetObject.SupportAction, sourceObject.SupportAction); } diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs index 98d0073..8078967 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs @@ -12,15 +12,15 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy combinationUpdateStrategy; public void Update(IBeamShearAxisAction targetObject, IBeamShearAxisAction sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); targetObject.Name = sourceObject.Name; targetObject.SupportForce = sourceObject.SupportForce.Clone() as IFactoredForceTuple; - CheckObject.IsNull(targetObject.ShearLoads); + CheckObject.ThrowIfNull(targetObject.ShearLoads); targetObject.ShearLoads.Clear(); - CheckObject.IsNull(sourceObject.ShearLoads); + CheckObject.ThrowIfNull(sourceObject.ShearLoads); foreach (var item in sourceObject.ShearLoads) { IBeamSpanLoad beamShearLoad = item.Clone() as IBeamSpanLoad; diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs index d0101d2..048f0a6 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs @@ -9,14 +9,14 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy combinationUpdateStrategy; public void Update(IBeamSpanLoad targetObject, IBeamSpanLoad sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.LoadRatio = sourceObject.LoadRatio; targetObject.RelativeLoadLevel = sourceObject.RelativeLoadLevel; - CheckObject.IsNull(sourceObject.CombinationProperty); - CheckObject.IsNull(targetObject.CombinationProperty); + CheckObject.ThrowIfNull(sourceObject.CombinationProperty); + CheckObject.ThrowIfNull(targetObject.CombinationProperty); combinationUpdateStrategy ??= new FactoredCombinationPropertyUpdateStrategy(); combinationUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty); } diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs index 4f250b8..fb96f1c 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs @@ -15,8 +15,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy distributedLoadUpdateStrategy; public void Update(IBeamSpanLoad targetObject, IBeamSpanLoad sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); UpdateObjects(targetObject, sourceObject); diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs index 9fcc365..147ffff 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy baseUpdateStrategy; public void Update(IConcentratedForce targetObject, IConcentratedForce sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); baseUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs index ea50b8d..9709446 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions private IUpdateStrategy baseUpdateStrategy; public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); baseUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs index b0ecd82..b9bb16d 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs @@ -10,8 +10,8 @@ namespace StructureHelperCommon.Models.Forces public void Update(IAction targetObject, IAction sourceObject) { forceUpdateStrategy ??= new ForceActionUpdateStrategy(); - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; if (targetObject is IForceAction forceAction) diff --git a/StructureHelperCommon/Models/Forces/Logics/CheckForceActionsLogic.cs b/StructureHelperCommon/Models/Forces/Logics/CheckForceActionsLogic.cs index 0972afb..947fcd8 100644 --- a/StructureHelperCommon/Models/Forces/Logics/CheckForceActionsLogic.cs +++ b/StructureHelperCommon/Models/Forces/Logics/CheckForceActionsLogic.cs @@ -1,10 +1,6 @@ -using StructureHelperCommon.Infrastructures.Exceptions; -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Interfaces; using System; using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces.Logics { @@ -15,6 +11,17 @@ namespace StructureHelperCommon.Models.Forces.Logics public string CheckResult => checkResult; public IShiftTraceLogger? TraceLogger { get; set; } + + public CheckForceActionsLogic(IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + } + + public CheckForceActionsLogic() + { + + } + public IEnumerable Entity { get; set; } public bool Check() diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs index 7e4bcbb..e5d88cf 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs @@ -24,7 +24,7 @@ namespace StructureHelperCommon.Models.Forces public IColumnFileProperty GetClone(IColumnFileProperty sourceObject) { - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(sourceObject); if (updateStrategy is null) { updateStrategy = new ColumnFilePropertyUpdateStrategy(); diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs index 1508e2f..1a302c9 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Forces { public void Update(IColumnFileProperty targetObject, IColumnFileProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.SearchingName = sourceObject.SearchingName; diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs index 184f9e8..a711848 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs @@ -14,8 +14,8 @@ namespace StructureHelperCommon.Models.Forces /// public void Update(IColumnedFileProperty targetObject, IColumnedFileProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } UpdateObjects(targetObject, sourceObject); } @@ -26,8 +26,8 @@ namespace StructureHelperCommon.Models.Forces targetObject.GlobalFactor = sourceObject.GlobalFactor; targetObject.SkipRowBeforeHeaderCount = sourceObject.SkipRowBeforeHeaderCount; targetObject.SkipRowHeaderCount = sourceObject.SkipRowHeaderCount; - CheckObject.IsNull(targetObject.ColumnProperties); - CheckObject.IsNull(sourceObject.ColumnProperties); + CheckObject.ThrowIfNull(targetObject.ColumnProperties); + CheckObject.ThrowIfNull(sourceObject.ColumnProperties); targetObject.ColumnProperties.Clear(); foreach (var item in sourceObject.ColumnProperties) { diff --git a/StructureHelperCommon/Models/Forces/Logics/DesignForceTupleUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/DesignForceTupleUpdateStrategy.cs index 4914500..02e02b4 100644 --- a/StructureHelperCommon/Models/Forces/Logics/DesignForceTupleUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/DesignForceTupleUpdateStrategy.cs @@ -24,8 +24,8 @@ namespace StructureHelperCommon.Models.Forces.Logics public void Update(IDesignForceTuple targetObject, IDesignForceTuple sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitState = sourceObject.LimitState; targetObject.CalcTerm = sourceObject.CalcTerm; diff --git a/StructureHelperCommon/Models/Forces/Logics/FactoredCombinationPropertyUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/FactoredCombinationPropertyUpdateStrategy.cs index aa69f6f..5d0c0e4 100644 --- a/StructureHelperCommon/Models/Forces/Logics/FactoredCombinationPropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/FactoredCombinationPropertyUpdateStrategy.cs @@ -7,8 +7,8 @@ namespace StructureHelperCommon.Models.Forces.Logics { public void Update(IFactoredCombinationProperty targetObject, IFactoredCombinationProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitState = sourceObject.LimitState; targetObject.ULSFactor = sourceObject.ULSFactor; diff --git a/StructureHelperCommon/Models/Forces/Logics/FactoredForceTupleUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/FactoredForceTupleUpdateStrategy.cs index 61a2015..8aae13f 100644 --- a/StructureHelperCommon/Models/Forces/Logics/FactoredForceTupleUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/FactoredForceTupleUpdateStrategy.cs @@ -12,12 +12,12 @@ namespace StructureHelperCommon.Models.Forces { public void Update(IFactoredForceTuple targetObject, IFactoredForceTuple sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.ForceTuple); + CheckObject.ThrowIfNull(sourceObject.ForceTuple); targetObject.ForceTuple = sourceObject.ForceTuple.Clone() as IForceTuple; - CheckObject.IsNull(sourceObject.CombinationProperty); + CheckObject.ThrowIfNull(sourceObject.CombinationProperty); targetObject.CombinationProperty = sourceObject.CombinationProperty.Clone() as IFactoredCombinationProperty; } } diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceActionBaseUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceActionBaseUpdateStrategy.cs index 1c5cf3f..f2c19e1 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceActionBaseUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceActionBaseUpdateStrategy.cs @@ -25,8 +25,8 @@ namespace StructureHelperCommon.Models.Forces public void Update(IForceAction targetObject, IForceAction sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.SetInGravityCenter = sourceObject.SetInGravityCenter; diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs index b640b13..9c3cf28 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs @@ -42,8 +42,8 @@ namespace StructureHelperCommon.Models.Forces public void Update(IForceAction targetObject, IForceAction sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } forceActionUpdateStrategy.Update(targetObject, sourceObject); UpdateChildProperties(targetObject, sourceObject); diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceCombinationFromFileUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceCombinationFromFileUpdateStrategy.cs index 5707d83..1fc86a8 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceCombinationFromFileUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceCombinationFromFileUpdateStrategy.cs @@ -30,14 +30,14 @@ namespace StructureHelperCommon.Models.Forces public void Update(IForceCombinationFromFile targetObject, IForceCombinationFromFile sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeLogics(); baseUpdateStrategy.Update(targetObject, sourceObject); targetObject.SkipWrongRows = sourceObject.SkipWrongRows; - CheckObject.IsNull(targetObject.CombinationProperty, "Target object combination property"); - CheckObject.IsNull(sourceObject.CombinationProperty, "Source object combination property"); + CheckObject.ThrowIfNull(targetObject.CombinationProperty, "Target object combination property"); + CheckObject.ThrowIfNull(sourceObject.CombinationProperty, "Source object combination property"); combinationPropertyUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty); targetObject.ForceFiles.Clear(); foreach (var file in sourceObject.ForceFiles) diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs index 67021ce..9607505 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs @@ -25,7 +25,7 @@ namespace StructureHelperCommon.Models.Forces public void Update(IForceCombinationList targetObject, IForceCombinationList sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.DesignForces.Clear(); foreach (var item in sourceObject.DesignForces) diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceFactoredListUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceFactoredListUpdateStrategy.cs index 2582177..4cd8811 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceFactoredListUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceFactoredListUpdateStrategy.cs @@ -34,15 +34,15 @@ namespace StructureHelperCommon.Models.Forces } public void Update(IForceFactoredList targetObject, IForceFactoredList sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } forceActionUpdateStrategy.Update(targetObject, sourceObject); - CheckObject.IsNull(sourceObject.CombinationProperty); - CheckObject.IsNull(targetObject.CombinationProperty); + CheckObject.ThrowIfNull(sourceObject.CombinationProperty); + CheckObject.ThrowIfNull(targetObject.CombinationProperty); propertyUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty); - CheckObject.IsNull(sourceObject.ForceTuples); - CheckObject.IsNull(targetObject.ForceTuples); + CheckObject.ThrowIfNull(sourceObject.ForceTuples); + CheckObject.ThrowIfNull(targetObject.ForceTuples); targetObject.ForceTuples.Clear(); foreach (var item in sourceObject.ForceTuples) { diff --git a/StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs index 25e6381..7227ae7 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs @@ -13,7 +13,7 @@ namespace StructureHelperCommon.Models.Forces { public void Update(IForceTuple targetObject, IForceTuple sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Mx = sourceObject.Mx; targetObject.My = sourceObject.My; diff --git a/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs index fb933c3..b510e38 100644 --- a/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs @@ -7,7 +7,7 @@ namespace StructureHelperCommon.Models.Forces.Logics { public void Update(IHasForceActions targetObject, IHasForceActions sourceObject) { - CheckObject.IsNull(targetObject, sourceObject, "Interface IHasForceCombination"); + CheckObject.ThrowIfNull(targetObject, sourceObject, "Interface IHasForceCombination"); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.ForceActions.Clear(); targetObject.ForceActions.AddRange(sourceObject.ForceActions); diff --git a/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs index 4ee7f45..475e002 100644 --- a/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Forces { public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.LoadValue = sourceObject.LoadValue; diff --git a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs index 6abab67..62b8bca 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries { public void Update(IMaterialPartialFactor targetObject, IMaterialPartialFactor sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitState = sourceObject.LimitState; targetObject.StressState = sourceObject.StressState; diff --git a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorBaseUpdateStrategy.cs b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorBaseUpdateStrategy.cs index e7328c6..a4823a4 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorBaseUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorBaseUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries { public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.Take = sourceObject.Take; diff --git a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs index 69b27e8..7c7f75d 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries private IUpdateStrategy baseUpdateStrategy = new MaterialSafetyFactorBaseUpdateStrategy(); public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy.Update(targetObject, sourceObject); targetObject.PartialFactors.Clear(); diff --git a/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs b/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs index 160666a..4b5ae8d 100644 --- a/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Projects { public void Update(IFileVersion targetObject, IFileVersion sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.VersionNumber = sourceObject.VersionNumber; targetObject.SubVersionNumber = sourceObject.SubVersionNumber; diff --git a/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs b/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs index f623a74..179df18 100644 --- a/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs @@ -26,8 +26,8 @@ namespace StructureHelperCommon.Models.Projects public void Update(IProject targetObject, IProject sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.VisualAnalyses.Clear(); foreach (var item in sourceObject.VisualAnalyses) diff --git a/StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs index d2c480e..2925f6a 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Shapes { public void Update(ICircleShape targetObject, ICircleShape sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Diameter = sourceObject.Diameter; } diff --git a/StructureHelperCommon/Models/Shapes/Logics/LinePolygonShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/LinePolygonShapeUpdateStrategy.cs index e703fc6..d49718a 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/LinePolygonShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/LinePolygonShapeUpdateStrategy.cs @@ -10,7 +10,7 @@ namespace StructureHelperCommon.Models.Shapes public void Update(ILinePolygonShape targetObject, ILinePolygonShape sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } // Update simple properties diff --git a/StructureHelperCommon/Models/Shapes/Logics/Point2DRangeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/Point2DRangeUpdateStrategy.cs index 8cd865b..4bd2f42 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/Point2DRangeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/Point2DRangeUpdateStrategy.cs @@ -8,12 +8,12 @@ namespace StructureHelperCommon.Models.Shapes private IUpdateStrategy pointUpdateStrategy; public void Update(IPoint2DRange targetObject, IPoint2DRange sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(targetObject.StartPoint, ": range start point"); + CheckObject.ThrowIfNull(targetObject.StartPoint, ": range start point"); pointUpdateStrategy ??= new Point2DUpdateStrategy(); pointUpdateStrategy.Update(targetObject.StartPoint, sourceObject.StartPoint); - CheckObject.IsNull(targetObject.EndPoint, ": range end point"); + CheckObject.ThrowIfNull(targetObject.EndPoint, ": range end point"); pointUpdateStrategy.Update(targetObject.EndPoint, sourceObject.EndPoint); } } diff --git a/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs index 156c34f..1f156a5 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs @@ -19,8 +19,8 @@ namespace StructureHelperCommon.Models.Shapes /// public void Update(IPoint2D targetObject, IPoint2D sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.X = sourceObject.X; targetObject.Y = sourceObject.Y; diff --git a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs index 73a2726..b00d47b 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Shapes { public void Update(IRectangleShape targetObject, IRectangleShape sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Width = sourceObject.Width; targetObject.Height = sourceObject.Height; diff --git a/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs index 4d98677..dda5fd2 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Shapes { public void Update(IShape targetObject, IShape sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } if (sourceObject is IRectangleShape sourceRectangle) { diff --git a/StructureHelperCommon/Models/Shapes/Logics/VertexUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/VertexUpdateStrategy.cs index 8dbbf21..fc78134 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/VertexUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/VertexUpdateStrategy.cs @@ -14,7 +14,7 @@ namespace StructureHelperCommon.Models.Shapes public void Update(IVertex targetObject, IVertex sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } if (UpdateChildren == true) { diff --git a/StructureHelperCommon/Models/States/StateCalcTermPairUpdateStrategy.cs b/StructureHelperCommon/Models/States/StateCalcTermPairUpdateStrategy.cs index e3cca49..eebad70 100644 --- a/StructureHelperCommon/Models/States/StateCalcTermPairUpdateStrategy.cs +++ b/StructureHelperCommon/Models/States/StateCalcTermPairUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.States { public void Update(IStateCalcTermPair targetObject, IStateCalcTermPair sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitState = sourceObject.LimitState; targetObject.CalcTerm = sourceObject.CalcTerm; diff --git a/StructureHelperCommon/Models/VisualProperties/PrimitiveVisualPropertyUpdateStrategy.cs b/StructureHelperCommon/Models/VisualProperties/PrimitiveVisualPropertyUpdateStrategy.cs index a9a074a..393bfe5 100644 --- a/StructureHelperCommon/Models/VisualProperties/PrimitiveVisualPropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/VisualProperties/PrimitiveVisualPropertyUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.VisualProperties { public void Update(IPrimitiveVisualProperty targetObject, IPrimitiveVisualProperty sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.IsVisible = sourceObject.IsVisible; targetObject.Color = sourceObject.Color; diff --git a/StructureHelperCommon/Models/WorkPlanes/WorkPlanePropertyUpdateStrategy.cs b/StructureHelperCommon/Models/WorkPlanes/WorkPlanePropertyUpdateStrategy.cs index 81aa3b1..db3d9d5 100644 --- a/StructureHelperCommon/Models/WorkPlanes/WorkPlanePropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/WorkPlanes/WorkPlanePropertyUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.WorkPlanes { public void Update(IWorkPlaneProperty targetObject, IWorkPlaneProperty sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.AxisLineThickness = sourceObject.AxisLineThickness; targetObject.GridSize = sourceObject.GridSize; diff --git a/StructureHelperCommon/Services/CheckObject.cs b/StructureHelperCommon/Services/CheckObject.cs index 23c9f82..5d031ef 100644 --- a/StructureHelperCommon/Services/CheckObject.cs +++ b/StructureHelperCommon/Services/CheckObject.cs @@ -24,7 +24,7 @@ namespace StructureHelperCommon.Services /// public static void CompareTypes(object targetObject, object sourceObject) { - IsNull(targetObject, sourceObject); + ThrowIfNull(targetObject, sourceObject); if (targetObject.GetType() != sourceObject.GetType()) { throw new StructureHelperException @@ -32,10 +32,10 @@ namespace StructureHelperCommon.Services } } - public static void IsNull(object targetObject, object sourceObject, string senderName = "") + public static void ThrowIfNull(object targetObject, object sourceObject, string senderName = "") { - IsNull(targetObject,$"{senderName} target object"); - IsNull(sourceObject, $"{senderName} source object"); + ThrowIfNull(targetObject,$"{senderName} target object"); + ThrowIfNull(sourceObject, $"{senderName} source object"); } /// @@ -44,7 +44,7 @@ namespace StructureHelperCommon.Services /// Checked object /// Message while error occur /// - public static void IsNull(object item, string message = "") + public static void ThrowIfNull(object item, string message = "") { if (item is null) { diff --git a/StructureHelperCommon/Services/Exports/EntitiesToDxfExportLogic.cs b/StructureHelperCommon/Services/Exports/EntitiesToDxfExportLogic.cs index 83897d8..1341e0d 100644 --- a/StructureHelperCommon/Services/Exports/EntitiesToDxfExportLogic.cs +++ b/StructureHelperCommon/Services/Exports/EntitiesToDxfExportLogic.cs @@ -12,7 +12,6 @@ namespace StructureHelperCommon.Services.Exports { public class EntitiesToDxfExportLogic : IExportToFileLogic { - private const double metresToMillimeters = 1000.0; private IGetDxfLayerLogic layerLogic = new GetDxfLayerLogic(); public List<(EntityObject entity, LayerNames layerName)> Entities { get; set; } = []; diff --git a/StructureHelperCommon/Services/Exports/GetDxfLayerLogic.cs b/StructureHelperCommon/Services/Exports/GetDxfLayerLogic.cs index b50db94..e1c9f6e 100644 --- a/StructureHelperCommon/Services/Exports/GetDxfLayerLogic.cs +++ b/StructureHelperCommon/Services/Exports/GetDxfLayerLogic.cs @@ -9,6 +9,7 @@ namespace StructureHelperCommon.Services.Exports private const string PrimitivesLayer = "STR-PRM"; private const string OpeningsLayer = "STR-OPN"; private const string RebarLayer = "STR-REB"; + private const string PointLayer = "STR-PNT"; private const string LayerNameIsUnKnown = ": Layer name is unknown"; public Layer GetOrCreateLayer(DxfDocument dxf, LayerNames layerName) { @@ -29,6 +30,7 @@ namespace StructureHelperCommon.Services.Exports if (layerName == LayerNames.StructiralPrimitives) { return PrimitivesLayer; } else if (layerName == LayerNames.StructuralOpenings) { return OpeningsLayer; } else if (layerName == LayerNames.StructuralRebars) { return RebarLayer; } + else if (layerName == LayerNames.StructuralPoints) { return PointLayer; } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(layerName) + LayerNameIsUnKnown); @@ -40,6 +42,7 @@ namespace StructureHelperCommon.Services.Exports if (layerName == LayerNames.StructiralPrimitives) { return AciColor.Blue; } else if (layerName == LayerNames.StructuralOpenings) { return AciColor.DarkGray; } else if (layerName == LayerNames.StructuralRebars) { return AciColor.Magenta; } + else if (layerName == LayerNames.StructuralPoints) { return AciColor.Green; } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(layerName) + LayerNameIsUnKnown); diff --git a/StructureHelperCommon/Services/Exports/ShapesExportToDxfLogic.cs b/StructureHelperCommon/Services/Exports/ShapesExportToDxfLogic.cs index 83127d4..e01939b 100644 --- a/StructureHelperCommon/Services/Exports/ShapesExportToDxfLogic.cs +++ b/StructureHelperCommon/Services/Exports/ShapesExportToDxfLogic.cs @@ -10,7 +10,8 @@ namespace StructureHelperCommon.Services.Exports { StructiralPrimitives, StructuralOpenings, - StructuralRebars + StructuralRebars, + StructuralPoints } public class ShapesExportToDxfLogic : IExportToFileLogic { diff --git a/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs b/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs index ca7c537..9e043a0 100644 --- a/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs @@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.Analyses public void Update(IBeamShearAnalysis targetObject, IBeamShearAnalysis sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; InitialzeStrategies(); analysisUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs index 52cfb66..29cf4f2 100644 --- a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs @@ -32,8 +32,8 @@ namespace StructureHelperLogics.Models.Analyses public void Update(ICrossSectionNdmAnalysis targetObject, ICrossSectionNdmAnalysis sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; analysisUpdateStrategy.Update(targetObject, sourceObject); targetObject.VersionProcessor.Versions.Clear(); diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs index a21cf88..f8b8123 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs @@ -14,11 +14,11 @@ namespace StructureHelperLogics.Models.BeamShears IUpdateStrategy repositoryUpdateStrategy; public void Update(IBeamShear targetObject, IBeamShear sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; - CheckObject.IsNull(sourceObject.Repository); - CheckObject.IsNull(targetObject.Repository); + CheckObject.ThrowIfNull(sourceObject.Repository); + CheckObject.ThrowIfNull(targetObject.Repository); InitializeStrategies(); clearStrategy.Process(targetObject.Repository); repositoryUpdateStrategy.Update(targetObject.Repository, sourceObject.Repository); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs index 3cc81b6..64a6238 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs @@ -10,13 +10,13 @@ namespace StructureHelperLogics.Models.BeamShears { public void Process(IBeamShearRepository entity) { - CheckObject.IsNull(entity.Calculators); + CheckObject.ThrowIfNull(entity.Calculators); entity.Calculators.Clear(); - CheckObject.IsNull(entity.Actions); + CheckObject.ThrowIfNull(entity.Actions); entity.Actions.Clear(); - CheckObject.IsNull(entity.Sections); + CheckObject.ThrowIfNull(entity.Sections); entity.Sections.Clear(); - CheckObject.IsNull(entity.Stirrups); + CheckObject.ThrowIfNull(entity.Stirrups); entity.Stirrups.Clear(); } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs index b2e1a3c..c5a43e6 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs @@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IBeamShearRepository targetObject, IBeamShearRepository sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.Actions.AddRange(sourceObject.Actions); targetObject.Sections.AddRange(sourceObject.Sections); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs index fc0406d..1b28eed 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs @@ -16,8 +16,8 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IBeamShearSection targetObject, IBeamShearSection sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } Check(targetObject, sourceObject); InitializeStrategies(); @@ -36,12 +36,12 @@ namespace StructureHelperLogics.Models.BeamShears private static void Check(IBeamShearSection targetObject, IBeamShearSection sourceObject) { - CheckObject.IsNull(sourceObject.Shape, "Source object shape"); - CheckObject.IsNull(targetObject.Shape, "Target object shape"); - CheckObject.IsNull(sourceObject.ConcreteMaterial, "Source concrete material"); - CheckObject.IsNull(targetObject.ConcreteMaterial, "Target concrete material"); - CheckObject.IsNull(sourceObject.ReinforcementMaterial, "Source reinforcement material"); - CheckObject.IsNull(targetObject.ReinforcementMaterial, "Target reinforcement material"); + CheckObject.ThrowIfNull(sourceObject.Shape, "Source object shape"); + CheckObject.ThrowIfNull(targetObject.Shape, "Target object shape"); + CheckObject.ThrowIfNull(sourceObject.ConcreteMaterial, "Source concrete material"); + CheckObject.ThrowIfNull(targetObject.ConcreteMaterial, "Target concrete material"); + CheckObject.ThrowIfNull(sourceObject.ReinforcementMaterial, "Source reinforcement material"); + CheckObject.ThrowIfNull(targetObject.ReinforcementMaterial, "Target reinforcement material"); } private void InitializeStrategies() diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs index 4f67b49..ce22760 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs @@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.BeamShears public IBeamShearCalculator GetClone(IBeamShearCalculator sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); InitializeStrategies(); BeamShearCalculator calculator = new(Guid.NewGuid()); updateStrategy.Update(calculator, sourceObject); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs index 9b54264..630768f 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs @@ -21,8 +21,8 @@ namespace StructureHelperLogics.Models.BeamShears public IBeamShearCalculatorInputData GetClone(IBeamShearCalculatorInputData sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); InitializeStrategies(); BeamShearCalculatorInputData inputData = new(Guid.NewGuid()); actionUpdateStrategy.Update(inputData, sourceObject); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs index 7e27796..39210d1 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs @@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Actions.Clear(); foreach (var item in sourceObject.Actions) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs index befb886..06c0706 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs @@ -17,9 +17,9 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Calculators.Clear(); foreach (var calculator in sourceObject.Calculators) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs index 3e22199..91d5269 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs @@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Sections.Clear(); foreach (var item in sourceObject.Sections) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs index 7d2fe1f..be13b9a 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs @@ -15,9 +15,9 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IHasStirrups targetObject, IHasStirrups sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Stirrups.Clear(); foreach (var item in sourceObject.Stirrups) diff --git a/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs index 6699bdb..11e345e 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs @@ -74,8 +74,8 @@ namespace StructureHelperLogics.Models.BeamShears private void Check() { - CheckObject.IsNull(BeamShearSection); - CheckObject.IsNull(DesignRangeProperty); + CheckObject.ThrowIfNull(BeamShearSection); + CheckObject.ThrowIfNull(DesignRangeProperty); } private void GetShapeParameters() diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs index ab86fe7..36e661d 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs @@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; - CheckObject.IsNull(sourceObject.Actions); - CheckObject.IsNull(targetObject.Actions); + CheckObject.ThrowIfNull(sourceObject.Actions); + CheckObject.ThrowIfNull(targetObject.Actions); targetObject.Actions.Clear(); targetObject.Actions.AddRange(sourceObject.Actions); } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs index d43b605..6bc72aa 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs @@ -13,11 +13,11 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; - CheckObject.IsNull(sourceObject.Sections); - CheckObject.IsNull(targetObject.Sections); + CheckObject.ThrowIfNull(sourceObject.Sections); + CheckObject.ThrowIfNull(targetObject.Sections); targetObject.Sections.Clear(); targetObject.Sections.AddRange(sourceObject.Sections); } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs index 1bae188..2eb1d48 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs @@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IHasStirrups targetObject, IHasStirrups sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; - CheckObject.IsNull(sourceObject.Stirrups); - CheckObject.IsNull(targetObject.Stirrups); + CheckObject.ThrowIfNull(sourceObject.Stirrups); + CheckObject.ThrowIfNull(targetObject.Stirrups); targetObject.Stirrups.Clear(); targetObject.Stirrups.AddRange(sourceObject.Stirrups); } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs index 5b17fb8..a34be8f 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/InclinedSectionUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IInclinedSection targetObject, IInclinedSection sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.StartCoord = sourceObject.StartCoord; targetObject.EndCoord = sourceObject.EndCoord; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs index b8e153e..15844b4 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupBaseUpdateStrategy.cs @@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IStirrup targetObject, IStirrup sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.CompressedGap = sourceObject.CompressedGap; @@ -24,8 +24,8 @@ namespace StructureHelperLogics.Models.BeamShears private void UpdateTargetChildren(IStirrup targetObject, IStirrup sourceObject) { - CheckObject.IsNull(sourceObject.VisualProperty); - CheckObject.IsNull(targetObject.VisualProperty); + CheckObject.ThrowIfNull(sourceObject.VisualProperty); + CheckObject.ThrowIfNull(targetObject.VisualProperty); visualUpdateStrategy ??= new PrimitiveVisualPropertyUpdateStrategy(); visualUpdateStrategy.Update(targetObject.VisualProperty, sourceObject.VisualProperty); } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs index dd421e1..276eefc 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByDensityUpdateStrategy.cs @@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears private IUpdateStrategy? baseUpdateStrategy; public void Update(IStirrupByDensity targetObject, IStirrupByDensity sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy ??= new StirrupBaseUpdateStrategy(); baseUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs index e9cc596..01bc5bb 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupByRebarUpdateStrategy.cs @@ -14,12 +14,12 @@ namespace StructureHelperLogics.Models.BeamShears private IUpdateStrategy? baseUpdateStrategy; public void Update(IStirrupByRebar targetObject, IStirrupByRebar sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy ??= new StirrupBaseUpdateStrategy(); baseUpdateStrategy.Update(targetObject, sourceObject); - CheckObject.IsNull(sourceObject.Material); + CheckObject.ThrowIfNull(sourceObject.Material); targetObject.Material = sourceObject.Material.Clone() as IReinforcementLibMaterial; targetObject.Diameter = sourceObject.Diameter; targetObject.LegCount = sourceObject.LegCount; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs index 6e7fba7..3390228 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StirrupUpdateStrategy.cs @@ -18,8 +18,8 @@ namespace StructureHelperLogics.Models.BeamShears.Logics public void Update(IStirrup targetObject, IStirrup sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } if (sourceObject is IStirrupGroup group) { diff --git a/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs index dd5cc31..ab0e792 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/StrengthLogics/StirrupByDensityStrengthLogic.cs @@ -72,8 +72,8 @@ namespace StructureHelperLogics.Models.BeamShears private void Check() { - CheckObject.IsNull(stirrupByDensity); - CheckObject.IsNull(inclinedSection); + CheckObject.ThrowIfNull(stirrupByDensity); + CheckObject.ThrowIfNull(inclinedSection); } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs index e3ae1e5..c070070 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorInputDataUpdateStrategy.cs @@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IBeamShearCalculatorInputData targetObject, IBeamShearCalculatorInputData sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; if (UpdateChildren) { @@ -24,8 +24,8 @@ namespace StructureHelperLogics.Models.BeamShears hasActionUpdateStrategy?.Update(targetObject, sourceObject); hasSectionsUpdateStrategy?.Update(targetObject, sourceObject); hasStirrupsUpdateStrategy?.Update(targetObject, sourceObject); - CheckObject.IsNull(sourceObject.DesignRangeProperty); - CheckObject.IsNull(targetObject.DesignRangeProperty); + CheckObject.ThrowIfNull(sourceObject.DesignRangeProperty); + CheckObject.ThrowIfNull(targetObject.DesignRangeProperty); designRangeUpdateStrategy.Update(targetObject.DesignRangeProperty, sourceObject.DesignRangeProperty); } targetObject.CodeType = sourceObject.CodeType; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs index 6adcf70..01def1c 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearCalculatorUpdateStrategy.cs @@ -9,8 +9,8 @@ namespace StructureHelperLogics.Models.BeamShears private IUpdateStrategy? inputDataUpdateStrategy; public void Update(IBeamShearCalculator targetObject, IBeamShearCalculator sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.Name = sourceObject.Name; targetObject.ShowTraceData = sourceObject.ShowTraceData; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs index 1f7c31b..24f9d68 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearDesignRangePropertyUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IBeamShearDesignRangeProperty targetObject, IBeamShearDesignRangeProperty sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.AbsoluteRangeValue = sourceObject.AbsoluteRangeValue; targetObject.RelativeEffectiveDepthRangeValue = sourceObject.RelativeEffectiveDepthRangeValue; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs index b9e29f7..4ea0470 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/BeamShearSectionLogicInputDataUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.BeamShears { public void Update(IBeamShearSectionLogicInputData targetObject, IBeamShearSectionLogicInputData sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.BeamShearAction = sourceObject.BeamShearAction; targetObject.InclinedSection = sourceObject.InclinedSection; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs index 886de87..ab24de5 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupByInclinedRebarUpdateStrategy.cs @@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IStirrupByInclinedRebar targetObject, IStirrupByInclinedRebar sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy ??= new StirrupBaseUpdateStrategy(); baseUpdateStrategy.Update(targetObject, sourceObject); @@ -25,7 +25,7 @@ namespace StructureHelperLogics.Models.BeamShears targetObject.LegCount = sourceObject.LegCount; if (UpdateChildren) { - CheckObject.IsNull(sourceObject.RebarSection, "Rebar section"); + CheckObject.ThrowIfNull(sourceObject.RebarSection, "Rebar section"); targetObject.RebarSection = sourceObject.RebarSection.Clone() as IRebarSection; } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs index 0fed14a..0223fd5 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/UpdateLogics/StirrupGroupUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperLogics.Models.BeamShears public void Update(IStirrupGroup targetObject, IStirrupGroup sourceObject) { - CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); - CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy ??= new StirrupBaseUpdateStrategy() { @@ -29,8 +29,8 @@ namespace StructureHelperLogics.Models.BeamShears private static void UpdateTargetChildren(IStirrupGroup targetObject, IStirrupGroup sourceObject) { - CheckObject.IsNull(sourceObject.Stirrups); - CheckObject.IsNull(targetObject.Stirrups); + CheckObject.ThrowIfNull(sourceObject.Stirrups); + CheckObject.ThrowIfNull(targetObject.Stirrups); targetObject.Stirrups.Clear(); foreach (var item in sourceObject.Stirrups) { diff --git a/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs b/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs index 888413c..1d799aa 100644 --- a/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs +++ b/StructureHelperLogics/Models/CrossSections/CrossSectionCloneStrategy.cs @@ -27,8 +27,8 @@ namespace StructureHelperLogics.Models.CrossSections { SectionRepository = newRepository }; - CheckObject.IsNull(targetObject.WorkPlaneProperty); - CheckObject.IsNull(sourceObject.WorkPlaneProperty); + CheckObject.ThrowIfNull(targetObject.WorkPlaneProperty); + CheckObject.ThrowIfNull(sourceObject.WorkPlaneProperty); workPlaneUpdateStrategy ??= new WorkPlanePropertyUpdateStrategy(); workPlaneUpdateStrategy.Update(targetObject.WorkPlaneProperty, sourceObject.WorkPlaneProperty); return targetObject; diff --git a/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs b/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs index 8384645..84026f1 100644 --- a/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs +++ b/StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryUpdateStrategy.cs @@ -16,8 +16,8 @@ namespace StructureHelperLogics.Models.CrossSections public void Update(ICrossSectionRepository targetObject, ICrossSectionRepository sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } } } diff --git a/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs b/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs index 39498d0..4911ad7 100644 --- a/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/CrossSections/CrossSectionUpdateStrategy.cs @@ -27,8 +27,8 @@ namespace StructureHelperLogics.Models.CrossSections public void Update(ICrossSection targetObject, ICrossSection sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } UpdateRepository(targetObject, sourceObject); UpdateWorkPlane(targetObject, sourceObject); @@ -48,8 +48,8 @@ namespace StructureHelperLogics.Models.CrossSections private void UpdateRepository(ICrossSection targetObject, ICrossSection sourceObject) { - CheckObject.IsNull(targetObject.SectionRepository); - CheckObject.IsNull(sourceObject.SectionRepository); + CheckObject.ThrowIfNull(targetObject.SectionRepository); + CheckObject.ThrowIfNull(sourceObject.SectionRepository); targetObject.SectionRepository.Calculators.Clear(); targetObject.SectionRepository.Primitives.Clear(); targetObject.SectionRepository.ForceActions.Clear(); diff --git a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs index 932c61a..f22b458 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs @@ -17,8 +17,8 @@ namespace StructureHelperLogics.Models.Materials } public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } libUpdateStrategy.Update(targetObject, sourceObject); targetObject.TensionForULS = sourceObject.TensionForULS; diff --git a/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs index b5f2741..0cebb88 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperLogics.Models.Materials { public void Update(IElasticMaterial targetObject, IElasticMaterial sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Modulus = sourceObject.Modulus; targetObject.CompressiveStrength = sourceObject.CompressiveStrength; diff --git a/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs index 220d58d..a43bdd1 100644 --- a/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs @@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.Materials /// public void Update(IFRMaterial targetObject, IFRMaterial sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Modulus = sourceObject.Modulus; targetObject.CompressiveStrength = sourceObject.CompressiveStrength; diff --git a/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs index 3a3521f..0baf2a3 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs @@ -23,9 +23,9 @@ namespace StructureHelperLogics.Models.Materials.Logics /// public void Update(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.HeadMaterials.Clear(); foreach (var material in sourceObject.HeadMaterials) diff --git a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs index 777f396..6be1039 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialBaseUpdateStrategy.cs @@ -8,8 +8,8 @@ namespace StructureHelperLogics.Models.Materials { public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.Color = sourceObject.Color; diff --git a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs index 5409c6b..789257f 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs @@ -26,8 +26,8 @@ namespace StructureHelperLogics.Models.Materials public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } baseUpdateStrategy.Update(targetObject, sourceObject); targetObject.HelperMaterial = sourceObject.HelperMaterial.Clone() as IHelperMaterial; diff --git a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs index 1d2b7e5..8c04ebd 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialSafetyFactorsUpdateStrategy.cs @@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.Materials.Logics { public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } if (sourceObject.SafetyFactors is not null) { diff --git a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs index e0f9fe3..695671f 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs @@ -40,8 +40,8 @@ namespace StructureHelperLogics.Models.Materials public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } safetyFactorUpdateStrategy.Update(targetObject, sourceObject); if (sourceObject is ILibMaterial) diff --git a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs index 1eb3873..dcfcb6f 100644 --- a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs @@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.Materials { public void Update(ILibMaterial targetObject, ILibMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.MaterialEntity = sourceObject.MaterialEntity; targetObject.MaterialLogic = sourceObject.MaterialLogic; diff --git a/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs index e158195..9fcdf62 100644 --- a/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/RebarSectionUpdateStrategy.cs @@ -9,10 +9,10 @@ namespace StructureHelperLogics.Models.Materials public void Update(IRebarSection targetObject, IRebarSection sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.IsNull(sourceObject.Material); + CheckObject.ThrowIfNull(sourceObject.Material); targetObject.Diameter = sourceObject.Diameter; if (UpdateChildren) { diff --git a/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs index 8888bb1..71ad5a8 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs @@ -20,8 +20,8 @@ namespace StructureHelperLogics.Models.Materials } public void Update(IReinforcementLibMaterial targetObject, IReinforcementLibMaterial sourceObject) { - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } libUpdateStrategy.Update(targetObject, sourceObject); } diff --git a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs index 69c9191..caec7f2 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs @@ -24,9 +24,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections { ValueDiagramCalculator diagramCalculator = new(Guid.NewGuid()) { Name = "New value diagram calcualtor"}; ValueDiagramEntity diagramEntity = new(Guid.NewGuid()) { Name = "New diagram" }; - diagramEntity.ValueDigram.Point2DRange.StartPoint.Y = 0.25; - diagramEntity.ValueDigram.Point2DRange.EndPoint.Y = - 0.25; - diagramCalculator.InputData.Digrams.Add(diagramEntity); + diagramEntity.ValueDiagram.Point2DRange.StartPoint.Y = 0.25; + diagramEntity.ValueDiagram.Point2DRange.EndPoint.Y = - 0.25; + diagramCalculator.InputData.Diagrams.Add(diagramEntity); return diagramCalculator; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs index 68a8671..81f4110 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs @@ -89,10 +89,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private void CheckActions() { - var checkLogic = new CheckForceActionsLogic() + var checkLogic = new CheckForceActionsLogic(TraceLogger) { - Entity = InputData.ForceActions, - TraceLogger = TraceLogger + Entity = InputData.ForceActions }; if (checkLogic.Check() == false) { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs index 6048620..e1b180e 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs @@ -41,7 +41,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces } public void Update(IForceCalculatorInputData targetObject, IForceCalculatorInputData sourceObject) { - CheckObject.IsNull(targetObject, sourceObject, "Force calculator input data"); + CheckObject.ThrowIfNull(targetObject, sourceObject, "Force calculator input data"); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Accuracy ??= new Accuracy(); targetObject.CheckStrainLimit = sourceObject.CheckStrainLimit; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs index 9b9dab3..eda64a4 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs @@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve { public void Update(ILimitCurvesCalculatorInputData targetObject, ILimitCurvesCalculatorInputData sourceObject) { - CheckObject.IsNull(targetObject, sourceObject, "Limit curve calculator input data"); + CheckObject.ThrowIfNull(targetObject, sourceObject, "Limit curve calculator input data"); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitStates.Clear(); targetObject.CalcTerms.Clear(); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs index 43e7d16..938966d 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs @@ -30,9 +30,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve public void Update(ILimitCurvesCalculator targetObject, ILimitCurvesCalculator sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } var targetData = targetObject.InputData; limitCurvesInputDataUpdateStrategy.Update(targetData, sourceObject.InputData); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs index 5f2bf03..8fb8563 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs @@ -33,9 +33,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } var sourceData = sourceObject.InputData; var targetData = targetObject.InputData; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs index 442e1c2..12d69d5 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs @@ -31,9 +31,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics public void Update(IForceCalculator targetObject, IForceCalculator sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } var sourceData = sourceObject.InputData; var targetData = targetObject.InputData; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs index e7b6b24..295a796 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs @@ -13,8 +13,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics public ForceCalculatorUpdateStrategy() : this(new ForceCalculatorInputDataUpdateStrategy()) { } public void Update(IForceCalculator targetObject, IForceCalculator sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.ShowTraceData = sourceObject.ShowTraceData; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs index e6ec42c..04e50b1 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs @@ -39,9 +39,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Calculators.Clear(); foreach (var calculator in sourceObject.Calculators) diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs index 1155d8f..1654a80 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramCalculatorInputData.cs @@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams /// /// Collection of diagram for calculation /// - List Digrams { get; } + List Diagrams { get; } bool CheckStrainLimit { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs index 3c5aa89..74cec02 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagramEntity.cs @@ -6,6 +6,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams { string Name { get; set; } bool IsTaken { get; set; } - IValueDiagram ValueDigram { get; set; } + IValueDiagram ValueDiagram { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs index 8bfeb61..99f6006 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorInputDataUpdateStrategy.cs @@ -21,7 +21,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public void Update(IValueDiagramCalculatorInputData targetObject, IValueDiagramCalculatorInputData sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.CheckStrainLimit = sourceObject.CheckStrainLimit; targetObject.StateTermPair.LimitState = sourceObject.StateTermPair.LimitState; @@ -32,12 +32,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams targetObject.Primitives.AddRange(sourceObject.Primitives); targetObject.ForceActions.Clear(); targetObject.ForceActions.AddRange(sourceObject.ForceActions); - targetObject.Digrams.Clear(); + targetObject.Diagrams.Clear(); entityUpdateStrategy ??= new ValueDiagramEntityUpdateStrategy(); - foreach (var entity in sourceObject.Digrams) + foreach (var entity in sourceObject.Diagrams) { var newItem = entity.Clone() as IValueDiagramEntity; - targetObject.Digrams.Add(newItem); + targetObject.Diagrams.Add(newItem); } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs index 1362ee4..d3c5f26 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs @@ -90,7 +90,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams private void GetEntitiesResults() { - var entities = InputData.Digrams + var entities = InputData.Diagrams .Where(x => x.IsTaken == true); foreach (var entity in entities) { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs index b456928..d1fd839 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs @@ -31,9 +31,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } var sourceData = sourceObject.InputData; var targetData = targetObject.InputData; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs index 1c853ed..c1495aa 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateStrategy.cs @@ -10,14 +10,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.ShowTraceData = sourceObject.ShowTraceData; if (UpdateChildren == true) { - CheckObject.IsNull(targetObject.InputData, ": target value diagram calculator input data"); - CheckObject.IsNull(sourceObject.InputData, ": source value diagram calculator input data"); + CheckObject.ThrowIfNull(targetObject.InputData, ": target value diagram calculator input data"); + CheckObject.ThrowIfNull(sourceObject.InputData, ": source value diagram calculator input data"); inputDataUpdateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy(); inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData); } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs new file mode 100644 index 0000000..486b5ff --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics +{ + public class ValueDiagramCheckLogic : CheckEntityLogic + { + private const double minDistance = 1e-3; + private bool result; + + public override bool Check() + { + result = true; + if (Entity is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": value diagram"; + TraceMessage(errorString); + throw new StructureHelperException(errorString); + } + double dx = Entity.Point2DRange.StartPoint.X - Entity.Point2DRange.EndPoint.X; + double dy = Entity.Point2DRange.StartPoint.Y - Entity.Point2DRange.EndPoint.Y; + if (Math.Abs(dx) < minDistance && Math.Abs(dy) < minDistance) + { + result = false; + TraceMessage($"Distance between point of diagram is too small"); + } + return result; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityCheckLogic.cs new file mode 100644 index 0000000..0c66cd9 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityCheckLogic.cs @@ -0,0 +1,46 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams +{ + public class ValueDiagramEntityCheckLogic : CheckEntityLogic + { + private ICheckEntityLogic valueDiagramCheckLogic; + + public ValueDiagramEntityCheckLogic(IShiftTraceLogger? traceLogger) + { + valueDiagramCheckLogic = new ValueDiagramCheckLogic(); + TraceLogger = traceLogger; + } + + public ValueDiagramEntityCheckLogic(ICheckEntityLogic valueDiagramCheckLogic, IShiftTraceLogger? traceLogger) + { + TraceLogger = traceLogger; + this.valueDiagramCheckLogic = valueDiagramCheckLogic; + } + + public override bool Check() + { + bool result = true; + if (Entity is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": value diagram entity"; + TraceMessage(errorString); + throw new StructureHelperException(errorString); + } + valueDiagramCheckLogic.Entity = Entity.ValueDiagram; + bool IsValid = valueDiagramCheckLogic.Check(); + if (IsValid == false) + { + result = false; + string name = string.IsNullOrWhiteSpace(Entity.Name) + ? "" + : Entity.Name; + TraceMessage($"Diagram: {name} has error: {valueDiagramCheckLogic.CheckResult}"); + } + return result; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs index 4780ab6..b3fba39 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityLogic.cs @@ -25,12 +25,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams private List GetPoints() { TraceLogger?.AddMessage($"Getting point for diagram {ValueDiagramEntity.Name} has been started"); - var startPoint = ValueDiagramEntity.ValueDigram.Point2DRange.StartPoint; - var endPoint = ValueDiagramEntity.ValueDigram.Point2DRange.EndPoint; - double dx = (endPoint.X - startPoint.X) / ValueDiagramEntity.ValueDigram.StepNumber; - double dy = (endPoint.Y - startPoint.Y) / ValueDiagramEntity.ValueDigram.StepNumber; + var startPoint = ValueDiagramEntity.ValueDiagram.Point2DRange.StartPoint; + var endPoint = ValueDiagramEntity.ValueDiagram.Point2DRange.EndPoint; + double dx = (endPoint.X - startPoint.X) / ValueDiagramEntity.ValueDiagram.StepNumber; + double dy = (endPoint.Y - startPoint.Y) / ValueDiagramEntity.ValueDiagram.StepNumber; List point2Ds = []; - for (int i = 0; i < ValueDiagramEntity.ValueDigram.StepNumber + 1; i++) + for (int i = 0; i < ValueDiagramEntity.ValueDiagram.StepNumber + 1; i++) { double x = startPoint.X + dx * i; double y = startPoint.Y + dy * i; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs index c46ea1a..9a09bc2 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramEntityUpdateStrategy.cs @@ -21,14 +21,14 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public void Update(IValueDiagramEntity targetObject, IValueDiagramEntity sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.IsTaken = sourceObject.IsTaken; targetObject.Name = sourceObject.Name; if (UpdateChildren == true) { valueDiagramUpdateStrategy ??= new ValueDiagramUpdateStrategy(); - valueDiagramUpdateStrategy.Update(targetObject.ValueDigram, sourceObject.ValueDigram); + valueDiagramUpdateStrategy.Update(targetObject.ValueDiagram, sourceObject.ValueDiagram); } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs new file mode 100644 index 0000000..14c9cee --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs @@ -0,0 +1,100 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.Logics; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Primitives.Logics; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams +{ + public class ValueDiagramInputDataCheckLogic : CheckEntityLogic + { + private ICheckEntityLogic checkEntityLogic; + private ICheckEntityLogic primitivesCheckLogic; + private ICheckEntityLogic> actionsCheckLogic; + + private bool result; + + public ValueDiagramInputDataCheckLogic( + ICheckEntityLogic checkEntityLogic, + ICheckEntityLogic primitivesCheckLogic, + ICheckEntityLogic> actionsCheckLogic) + { + this.checkEntityLogic = checkEntityLogic; + this.primitivesCheckLogic = primitivesCheckLogic; + this.actionsCheckLogic = actionsCheckLogic; + } + + public ValueDiagramInputDataCheckLogic() + { + checkEntityLogic = new ValueDiagramEntityCheckLogic(TraceLogger); + CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new() + { + CheckRebarHostMaterial = false, + CheckRebarPlacement = false + }; + primitivesCheckLogic = new CheckPrimitiveCollectionLogic(TraceLogger, checkRebarPrimitiveLogic); + actionsCheckLogic = new CheckForceActionsLogic(TraceLogger); + } + + public override bool Check() + { + result = true; + if (Entity is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": input data"; + TraceMessage(errorString); + throw new StructureHelperException(errorString); + } + if (Entity.Primitives is null || !Entity.Primitives.Any()) + { + TraceMessage("Calculator does not contain any primitives"); + result = false; + } + if (Entity.ForceActions is null || !Entity.ForceActions.Any()) + { + TraceMessage("Calculator does not contain any forces"); + result = false; + } + if (Entity.Diagrams is null || !Entity.Diagrams.Any() || !Entity.Diagrams.Where(x=> x.IsTaken == true).Any()) + { + TraceMessage("Calculator does not contain any diagrams for calculation"); + result = false; + } + foreach (var entity in Entity.Diagrams) + { + checkEntityLogic.Entity = entity; + bool isValid = checkEntityLogic.Check(); + if (isValid == false) + { + result = false; + TraceMessage(checkEntityLogic.CheckResult); + } + } + CheckPrimitives(); + CheckActions(); + return result; + } + + private void CheckPrimitives() + { + primitivesCheckLogic.Entity = Entity; + if (primitivesCheckLogic.Check() == false) + { + result = false; + } + TraceMessage(primitivesCheckLogic.CheckResult); + + } + + private void CheckActions() + { + actionsCheckLogic.Entity = Entity.ForceActions; + if (actionsCheckLogic.Check() == false) + { + result = false; + } + TraceMessage(actionsCheckLogic.CheckResult); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs index f90a890..bebaa66 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services; @@ -6,19 +7,36 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams { public class ValueDiagramUpdateStrategy : IParentUpdateStrategy { - private IUpdateStrategy rangeUpdateStrategy; + private IUpdateStrategy? _rangeUpdateStrategy; + + public ValueDiagramUpdateStrategy(IUpdateStrategy rangeUpdateStrategy) + { + _rangeUpdateStrategy = rangeUpdateStrategy ?? throw new StructureHelperException("rangeUpdateStrategy cannot be null"); + } + + public ValueDiagramUpdateStrategy() { } + public bool UpdateChildren { get; set; } = true; + private IUpdateStrategy RangeUpdateStrategy + => _rangeUpdateStrategy ??= new Point2DRangeUpdateStrategy(); + public void Update(IValueDiagram targetObject, IValueDiagram sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); - if (ReferenceEquals(targetObject, sourceObject)) { return; } + CheckObject.ThrowIfNull(targetObject, nameof(targetObject)); + CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject)); + + if (ReferenceEquals(targetObject, sourceObject)) + return; + targetObject.StepNumber = sourceObject.StepNumber; - if (UpdateChildren == true) + + if (UpdateChildren) { - rangeUpdateStrategy ??= new Point2DRangeUpdateStrategy(); - rangeUpdateStrategy.Update(targetObject.Point2DRange, sourceObject.Point2DRange); + // Use property for lazy initialization + RangeUpdateStrategy.Update(targetObject.Point2DRange, sourceObject.Point2DRange); } } } + } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs index 674182d..0540b60 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs @@ -4,8 +4,17 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams { public class ValueDiagram : IValueDiagram { + private int stepNumber = 50; + public Guid Id { get; } - public int StepNumber { get; set; } = 50; + public int StepNumber + { + get => stepNumber; + set + { + stepNumber = Math.Max(value, 10); + } + } public IPoint2DRange Point2DRange { get; set; } = new Point2DRange(Guid.NewGuid()); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs index 4421ba4..22efb71 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculator.cs @@ -1,13 +1,17 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics; namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams { public class ValueDiagramCalculator : IValueDiagramCalculator { private readonly IValueDiagramCalculatorLogic valueDiagramCalculatorLogic = new ValueDiagramCalculatorLogic(); - private readonly ICheckInputDataLogic checkInputDataLogic; + private readonly ICheckEntityLogic checkInputDataLogic; + + private IValueDiagramCalculatorResult result; public Guid Id { get; } @@ -20,9 +24,15 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public IValueDiagramCalculatorInputData InputData { get; set; } = new ValueDiagramCalculatorInputData(Guid.NewGuid()); + public ValueDiagramCalculator(ICheckEntityLogic checkInputDataLogic) + { + this.checkInputDataLogic = checkInputDataLogic; + } + public ValueDiagramCalculator(Guid id) { Id = id; + checkInputDataLogic = new ValueDiagramInputDataCheckLogic(); } public object Clone() @@ -35,6 +45,16 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public void Run() { + checkInputDataLogic.Entity = InputData; + if (checkInputDataLogic.Check() != true) + { + result = new ValueDiagramCalculatorResult() + { + IsValid = false, + Description = checkInputDataLogic.CheckResult + }; + return; + } valueDiagramCalculatorLogic.InputData = InputData; result = valueDiagramCalculatorLogic.GetResult(); } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs index 3282409..01272d7 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramCalculatorInputData.cs @@ -17,7 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public Guid Id { get; } /// - public List Digrams { get; } = []; + public List Diagrams { get; } = []; /// public List ForceActions { get; } = []; /// diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs index b71c676..91b4db6 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagramEntity.cs @@ -6,7 +6,7 @@ public string Name { get; set; } = string.Empty; public bool IsTaken { get; set; } = true; - public IValueDiagram ValueDigram { get; set; } = new ValueDiagram(Guid.NewGuid()); + public IValueDiagram ValueDiagram { get; set; } = new ValueDiagram(Guid.NewGuid()); public ValueDiagramEntity(Guid id) { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs index df89277..5e00981 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs @@ -69,10 +69,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage(message, TraceLogStatuses.Error); return; }; - var checkLogic = new CheckForceActionsLogic() + var checkLogic = new CheckForceActionsLogic(TraceLogger) { - Entity = InputData.ForceActions, - TraceLogger = TraceLogger + Entity = InputData.ForceActions }; if (checkLogic.Check() == false) { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs index 035b6c9..274edec 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs @@ -14,8 +14,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public CrackCalculatorUpdateStrategy() : this(new CrackInputDataUpdateStrategy()) { } public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.ShowTraceData = sourceObject.ShowTraceData; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs index ad48d51..17c5884 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs @@ -22,8 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } public void Update(ICrackCalculatorInputData targetObject, ICrackCalculatorInputData sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.ForceActions.Clear(); targetObject.ForceActions.AddRange(sourceObject.ForceActions); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs index 99b25a7..07ea58c 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs @@ -12,8 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public void Update(IUserCrackInputData targetObject, IUserCrackInputData sourceObject) { - CheckObject.IsNull(targetObject); - CheckObject.IsNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + CheckObject.ThrowIfNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.SetSofteningFactor = sourceObject.SetSofteningFactor; targetObject.SofteningFactor = sourceObject.SofteningFactor; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs index 6277a25..7498e9e 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/DxfEntitiesToNdmPrimitivesConvertStrategy.cs @@ -2,6 +2,7 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Exports; +using StructureHelperLogics.Models.Primitives; namespace StructureHelperLogics.NdmCalculations.Primitives { @@ -31,6 +32,10 @@ namespace StructureHelperLogics.NdmCalculations.Primitives { primitives.Add(GetCirclePrimitive(circle)); } + else if (dxfEntity is Point point) + { + primitives.Add(GetPointPrimitive(point)); + } else { // just skip all types of primitives @@ -39,6 +44,31 @@ namespace StructureHelperLogics.NdmCalculations.Primitives } } + private INdmPrimitive GetPointPrimitive(Point point) + { + INdmPrimitive primitive = null; + double area = 0.000314; + if (point.Layer.Name == layerLogic.GetLayerName(LayerNames.StructuralRebars)) + { + RebarNdmPrimitive rebar = new(Guid.NewGuid()) + { + Name = "Imported rebar", + Area = area + }; + primitive = rebar; + } + else + { + PointNdmPrimitive pointPrimitive = new(Guid.NewGuid()) + { + Name = "Imported point", + Area = area + }; + primitive = pointPrimitive; + } + return primitive; + } + private INdmPrimitive GetCirclePrimitive(Circle circle) { INdmPrimitive primitive = null; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs index e9ae41c..2d023c1 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs @@ -27,8 +27,8 @@ namespace StructureHelperLogics.NdmCalculations.Primitives } public void Update(IEllipseNdmPrimitive targetObject, IEllipseNdmPrimitive sourceObject) { - CheckObject.IsNull(sourceObject, "source object"); - CheckObject.IsNull(targetObject, "target object"); + CheckObject.ThrowIfNull(sourceObject, "source object"); + CheckObject.ThrowIfNull(targetObject, "target object"); if (ReferenceEquals(targetObject, sourceObject)) { return; } basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs index a421dee..285e0de 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs @@ -18,9 +18,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject) { - CheckObject.IsNull(cloningStrategy); - CheckObject.IsNull(sourceObject); - CheckObject.IsNull(targetObject); + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Primitives.Clear(); foreach (var primitive in sourceObject.Primitives) diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs index 6904802..b224f43 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateStrategy.cs @@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Primitives.Clear(); targetObject.Primitives.AddRange(sourceObject.Primitives); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs index c14e6a8..7b0a991 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs @@ -24,7 +24,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics /// public void Update(INdmElement targetObject, INdmElement sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Triangulate = sourceObject.Triangulate; tupleUpdateStrategy.Update(targetObject.UsersPrestrain, sourceObject.UsersPrestrain); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs index a6b3962..f65985c 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveBaseUpdateStrategy.cs @@ -16,7 +16,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public void Update(INdmPrimitive targetObject, INdmPrimitive sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); targetObject.Name = sourceObject.Name; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs index 310a8d2..946db08 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs @@ -28,8 +28,8 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public void Update(IRectangleNdmPrimitive targetObject, IRectangleNdmPrimitive sourceObject) { - CheckObject.IsNull(sourceObject, "source object"); - CheckObject.IsNull(targetObject, "target object"); + CheckObject.ThrowIfNull(sourceObject, "source object"); + CheckObject.ThrowIfNull(targetObject, "target object"); if (ReferenceEquals(targetObject, sourceObject)) { return; } basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs index 4435b0c..f0c03dc 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ShapeNDMPrimitiveUpdateStrategy.cs @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public void Update(IShapeNdmPrimitive targetObject, IShapeNdmPrimitive sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.ThrowIfNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } InitializeStrategies(); basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs index 314503d..25d9435 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs @@ -11,7 +11,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT { public class RCSectionsTest { - [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068471024318306586d, -0.0030411189808055242d, 0.00034289928716916179d)] + [TestCase(0.4d, 0.6d, 0.012d, 0.025d, 2, 2, false, -0.00068593466107645337d, -0.0030411189808055242d, 0.00034289928716916179d)] public void Run_ShouldPass(double width, double height, double topDiametr, double bottomDiametr, int widthCount, int heightCount, bool isBuckling, double expectedKx, double expectedKy, double expectedEpsZ) { //Arrange diff --git a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs index 44c3211..63bae84 100644 --- a/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs +++ b/StructureHelperTests/UnitTests/MaterialTests/MaterialStrengthTest.cs @@ -14,10 +14,10 @@ namespace StructureHelperTests.UnitTests.MaterialTests [TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 434782608.69565225d, 434782608.69565225d)] [TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 5e8d, 5e8d)] [TestCase(HeadmaterialType.Reinforcement500, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 5e8d, 5e8d)] - [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 22461538.46153846d, 1395297.0017909051d)] - [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 20215384.615384616d, 1255767.3016118146d)] - [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 29200000.0d, 2092945.5026863578d)] - [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.LongTerm, 29200000.0d, 2092945.5026863578d)] + [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.ShortTerm, 22199999.999999996d, 1395297.0017909051d)] + [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.ULS, CalcTerms.LongTerm, 19980000.0d, 1255767.3016118146d)] + [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.ShortTerm, 28860000.0d, 2092945.5026863578d)] + [TestCase(HeadmaterialType.Concrete40, CodeTypes.SP63_2018, LimitStates.SLS, CalcTerms.LongTerm, 28860000.0d, 2092945.5026863578d)] public void Run_ShouldPass(HeadmaterialType headmaterialType, CodeTypes code, LimitStates limitState, CalcTerms calcTerm, double expectedCompressive, double expectedTensile) { //Arrange diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs index b43ca6d..ad51f06 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs @@ -6,6 +6,7 @@ using StructureHelperLogics.Models.Primitives; using StructureHelperLogics.NdmCalculations.Primitives.Logics; using StructureHelperLogics.NdmCalculations.Primitives; using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelper.Models.Materials; namespace StructureHelperTests.UnitTests.Ndms @@ -53,9 +54,14 @@ namespace StructureHelperTests.UnitTests.Ndms { // Arrange var rebarMock = new Mock(); + var ndmElementMoq = new Mock(); + var headMaterialMoq = new Mock(); + _mockHasPrimitives.Setup(x => x.Primitives).Returns(new List { rebarMock.Object }); _mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(false); _mockCheckRebarPrimitiveLogic.Setup(x => x.CheckResult).Returns("Rebar check failed\n"); + rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object); + ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object); // Act var result = _mockCheckPrimitiveCollectionLogic.Object.Check(); @@ -71,10 +77,14 @@ namespace StructureHelperTests.UnitTests.Ndms // Arrange var rebarMock = new Mock(); var hostPrimitiveMock = new Mock(); + var ndmElementMoq = new Mock(); + var headMaterialMoq = new Mock(); rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object); rebarMock.Setup(x => x.Name).Returns("RebarName"); hostPrimitiveMock.Setup(x => x.Name).Returns("HostPrimitiveName"); + rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object); + ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object); _mockHasPrimitives.Setup(x => x.Primitives).Returns(new List { rebarMock.Object }); _mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(true); // Assume rebar check passes @@ -93,10 +103,16 @@ namespace StructureHelperTests.UnitTests.Ndms { // Arrange var rebarMock = new Mock(); + var ndmElementMoq = new Mock(); + var headMaterialMoq = new Mock(); var hostPrimitiveMock = new Mock(); rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object); rebarMock.Setup(x => x.Name).Returns("RebarName"); + rebarMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object); + ndmElementMoq.Setup(x => x.HeadMaterial).Returns(headMaterialMoq.Object); + hostPrimitiveMock.Setup(x => x.NdmElement).Returns(ndmElementMoq.Object); + _mockHasPrimitives.Setup(x => x.Primitives).Returns(new List { rebarMock.Object, hostPrimitiveMock.Object }); _mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(true); diff --git a/StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs b/StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs index 1157a0e..819c8f7 100644 --- a/StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs +++ b/StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs @@ -4,6 +4,7 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Calculators; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; using System; using System.Collections.Generic; @@ -15,26 +16,31 @@ namespace StructureHelperTests.UnitTests.UpdateStrategiesTests [TestFixture] public class HasCalculatorsUpdateCloningStrategyTests { + private Mock _cloningStrategyContainerMoq; private Mock _cloningStrategyMock; private Mock> _forceCalculatorUpdateStrategyMock; private Mock> _crackCalculatorUpdateStrategyMock; private Mock> _limitCurvesCalculatorUpdateStrategyMock; + private Mock> _valueDiagramCalculatorUpdateStrategyMock; private HasCalculatorsUpdateCloningStrategy _strategy; [SetUp] public void SetUp() { + _cloningStrategyContainerMoq = new Mock(); _cloningStrategyMock = new Mock(); _forceCalculatorUpdateStrategyMock = new Mock>(); _crackCalculatorUpdateStrategyMock = new Mock>(); _limitCurvesCalculatorUpdateStrategyMock = new Mock>(); + _valueDiagramCalculatorUpdateStrategyMock = new Mock>(); + _cloningStrategyContainerMoq.Setup(m => m.ForceCalculatorStrategy).Returns(_forceCalculatorUpdateStrategyMock.Object); + _cloningStrategyContainerMoq.Setup(m => m.CrackCalculatorStrategy).Returns(_crackCalculatorUpdateStrategyMock.Object); + _cloningStrategyContainerMoq.Setup(m => m.LimitCurvesCalculatorStrategy).Returns(_limitCurvesCalculatorUpdateStrategyMock.Object); + _cloningStrategyContainerMoq.Setup(m => m.ValueDiagramCalculatorStrategy).Returns(_valueDiagramCalculatorUpdateStrategyMock.Object); _strategy = new HasCalculatorsUpdateCloningStrategy( _cloningStrategyMock.Object, - _forceCalculatorUpdateStrategyMock.Object, - _crackCalculatorUpdateStrategyMock.Object, - _limitCurvesCalculatorUpdateStrategyMock.Object - ); + _cloningStrategyContainerMoq.Object); } [Test] diff --git a/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramCalculatorUpdateCloningStrategyTests.cs b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramCalculatorUpdateCloningStrategyTests.cs new file mode 100644 index 0000000..e30dfbd --- /dev/null +++ b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramCalculatorUpdateCloningStrategyTests.cs @@ -0,0 +1,89 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperTests.UnitTests.ValueDiagramsTests +{ + using Moq; + using NUnit.Framework; + using StructureHelperCommon.Infrastructures.Exceptions; + + [TestFixture] + public class ValueDiagramCalculatorUpdateCloningStrategyTests + { + private Mock _cloningStrategyMock; + private Mock> _forcesUpdateMock; + private Mock> _primitivesUpdateMock; + private ValueDiagramCalculatorUpdateCloningStrategy _strategy; + + private Mock _sourceMock; + private Mock _targetMock; + private Mock _inputDataMock; + + [SetUp] + public void Setup() + { + _cloningStrategyMock = new Mock(); + _forcesUpdateMock = new Mock>(); + _primitivesUpdateMock = new Mock>(); + + _strategy = new ValueDiagramCalculatorUpdateCloningStrategy( + _cloningStrategyMock.Object, + _forcesUpdateMock.Object, + _primitivesUpdateMock.Object + ); + + _sourceMock = new Mock(); + _targetMock = new Mock(); + _inputDataMock = new Mock(); + + // Both source and target share the same interface object type + _sourceMock.Setup(s => s.InputData).Returns(_inputDataMock.Object); + _targetMock.Setup(t => t.InputData).Returns(_inputDataMock.Object); + } + + [Test] + public void Update_SourceObjectIsNull_Throws() + { + Assert.That( + () => _strategy.Update(_targetMock.Object, null), + Throws.Exception.TypeOf() + ); + } + + [Test] + public void Update_TargetObjectIsNull_Throws() + { + Assert.That( + () => _strategy.Update(null, _sourceMock.Object), + Throws.Exception.TypeOf() + ); + } + + [Test] + public void Update_TargetAndSourceAreSame_DoesNothing() + { + _strategy.Update(_targetMock.Object, _targetMock.Object); + + _primitivesUpdateMock.Verify(p => p.Update(It.IsAny(), It.IsAny()), Times.Never); + _forcesUpdateMock.Verify(f => f.Update(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void Update_CallsPrimitivesAndForcesStrategies() + { + // Act + _strategy.Update(_targetMock.Object, _sourceMock.Object); + + // Assert: Both strategies are called with the same InputData object + _primitivesUpdateMock.Verify(p => p.Update(_inputDataMock.Object, _inputDataMock.Object), Times.Once); + _forcesUpdateMock.Verify(f => f.Update(_inputDataMock.Object, _inputDataMock.Object), Times.Once); + } + + } +} diff --git a/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramEntityCheckLogicTests.cs b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramEntityCheckLogicTests.cs new file mode 100644 index 0000000..2a3a23b --- /dev/null +++ b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramEntityCheckLogicTests.cs @@ -0,0 +1,120 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; + +namespace StructureHelperTests.UnitTests.ValueDiagramsTests +{ + [TestFixture] + public class ValueDiagramEntityCheckLogicTests + { + private Mock> _diagramCheckMock; + private Mock _loggerMock; + private ValueDiagramEntityCheckLogic _logic; + + [SetUp] + public void Setup() + { + _diagramCheckMock = new Mock>(); + _loggerMock = new Mock(); + _logic = new ValueDiagramEntityCheckLogic(_diagramCheckMock.Object, _loggerMock.Object); + } + + [Test] + public void Check_EntityIsNull_ThrowsStructureHelperException() + { + // Arrange + _logic.Entity = null; + + // Act + Assert + Assert.That( + () => _logic.Check(), + Throws.Exception.TypeOf() + ); + } + + [Test] + public void Check_DiagramCheckPasses_ReturnsTrue() + { + // Arrange + var entity = new Mock(); + var diagram = new Mock().Object; + + entity.Setup(e => e.ValueDiagram).Returns(diagram); + entity.Setup(e => e.Name).Returns("TestDiagram"); + + _logic.Entity = entity.Object; + + _diagramCheckMock.Setup(c => c.Check()).Returns(true); + + // Act + var result = _logic.Check(); + + // Assert + Assert.That(result, Is.True); + + _diagramCheckMock.VerifySet(c => c.Entity = diagram, Times.Once); + _diagramCheckMock.Verify(c => c.Check(), Times.Once); + + _loggerMock.Verify(l => l.AddMessage(It.IsAny()), Times.Never); + } + + [Test] + public void Check_DiagramCheckFails_ReturnsFalse_AndLogsError() + { + // Arrange + var entity = new Mock(); + var diagram = new Mock().Object; + + entity.Setup(e => e.ValueDiagram).Returns(diagram); + entity.Setup(e => e.Name).Returns("MyDiagram"); + + _logic.Entity = entity.Object; + + _diagramCheckMock.Setup(c => c.Check()).Returns(false); + _diagramCheckMock.Setup(c => c.CheckResult).Returns("child error message"); + + // Act + var result = _logic.Check(); + + // Assert + Assert.That(result, Is.False); + + _diagramCheckMock.Verify(c => c.Check(), Times.Once); + + _loggerMock.Verify( + l => l.AddMessage(It.Is(s => s.Contains("Diagram: MyDiagram has error: child error message"))), + Times.Once + ); + } + + [Test] + public void Check_EntityNameIsNull_UsesUnnamedInMessage() + { + // Arrange + var entity = new Mock(); + var diagram = new Mock().Object; + + entity.Setup(e => e.ValueDiagram).Returns(diagram); + entity.Setup(e => e.Name).Returns((string)null); + + _logic.Entity = entity.Object; + + _diagramCheckMock.Setup(c => c.Check()).Returns(false); + _diagramCheckMock.Setup(c => c.CheckResult).Returns("xyz"); + + // Act + var result = _logic.Check(); + + // Assert + Assert.That(result, Is.False); + + _loggerMock.Verify( + l => l.AddMessage(It.Is(s => s.Contains(""))), + Times.Once + ); + } + } +} diff --git a/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramUpdateStrategyTests.cs b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramUpdateStrategyTests.cs new file mode 100644 index 0000000..87268ac --- /dev/null +++ b/StructureHelperTests/UnitTests/ValueDiagramsTests/ValueDiagramUpdateStrategyTests.cs @@ -0,0 +1,110 @@ +using Moq; +using NUnit.Framework; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; + +namespace StructureHelperTests.UnitTests.ValueDiagramsTests +{ + + + [TestFixture] + public class ValueDiagramUpdateStrategyTests + { + private Mock> _rangeUpdateMock; + private ValueDiagramUpdateStrategy _strategy; + private Mock _targetMock; + private Mock _sourceMock; + private Mock _targetRangeMock; + private Mock _sourceRangeMock; + + [SetUp] + public void Setup() + { + _rangeUpdateMock = new Mock>(); + _strategy = new ValueDiagramUpdateStrategy(_rangeUpdateMock.Object); + + _targetMock = new Mock(); + _sourceMock = new Mock(); + _targetRangeMock = new Mock(); + _sourceRangeMock = new Mock(); + + _targetMock.Setup(t => t.Point2DRange).Returns(_targetRangeMock.Object); + _sourceMock.Setup(s => s.Point2DRange).Returns(_sourceRangeMock.Object); + } + + [Test] + public void Update_TargetIsNull_Throws() + { + Assert.That( + () => _strategy.Update(null, _sourceMock.Object), + Throws.Exception.TypeOf() + ); + } + + [Test] + public void Update_SourceIsNull_Throws() + { + Assert.That( + () => _strategy.Update(_targetMock.Object, null), + Throws.Exception.TypeOf() + ); + } + + [Test] + public void Update_TargetEqualsSource_DoesNothing() + { + _strategy.Update(_targetMock.Object, _targetMock.Object); + + _rangeUpdateMock.Verify(r => r.Update(It.IsAny(), It.IsAny()), Times.Never); + } + + [Test] + public void Update_CopiesStepNumber_AndCallsRangeUpdate() + { + _sourceMock.Setup(s => s.StepNumber).Returns(5); + + _strategy.Update(_targetMock.Object, _sourceMock.Object); + + _targetMock.VerifySet(t => t.StepNumber = 5, Times.Once); + _rangeUpdateMock.Verify(r => r.Update(_targetRangeMock.Object, _sourceRangeMock.Object), Times.Once); + } + + [Test] + public void Update_LazyInitializesRangeUpdateStrategy_WhenNotProvided() + { + // Use parameterless constructor + var strategy = new ValueDiagramUpdateStrategy(); + var targetMock = new Mock(); + var sourceMock = new Mock(); + var targetRangeMock = new Mock(); + var sourceRangeMock = new Mock(); + var pointMoq = new Mock(); + + targetMock.Setup(t => t.Point2DRange).Returns(targetRangeMock.Object); + sourceMock.Setup(s => s.Point2DRange).Returns(sourceRangeMock.Object); + sourceRangeMock.Setup(s => s.StartPoint).Returns(pointMoq.Object); + sourceRangeMock.Setup(s => s.EndPoint).Returns(pointMoq.Object); + targetRangeMock.Setup(s => s.StartPoint).Returns(pointMoq.Object); + targetRangeMock.Setup(s => s.EndPoint).Returns(pointMoq.Object); + + // This should create Point2DRangeUpdateStrategy lazily + Assert.DoesNotThrow(() => strategy.Update(targetMock.Object, sourceMock.Object)); + + // No exception means lazy initialization worked + // Cannot directly mock the default Point2DRangeUpdateStrategy, but at least this ensures no null reference + } + + [Test] + public void Update_DoesNotCallRangeUpdate_WhenUpdateChildrenIsFalse() + { + _strategy.UpdateChildren = false; + + _strategy.Update(_targetMock.Object, _sourceMock.Object); + + _rangeUpdateMock.Verify(r => r.Update(It.IsAny(), It.IsAny()), Times.Never); + } + } + +}