/// <summary> /// Checks for errors before applying a rule. /// </summary> /// <param name="node">The node instance to check.</param> /// <param name="dataList">Optional data collected during inspection of sources.</param> /// <param name="data">Private data to give to Apply() upon return.</param> /// <returns>True if an error occured.</returns> public override bool CheckConsistency(IConstantFeature node, IDictionary <ISourceTemplate, object> dataList, out object data) { data = null; bool Success = true; IName EntityName = (IName)((IFeatureWithName)node).EntityName; IObjectType TypeToResolve = (IObjectType)node.EntityType; IClass EmbeddingClass = node.EmbeddingClass; if (TypeToResolve.ResolvedType.Item is IClassType AsClassType) { if (AsClassType.BaseClass.Cloneable == BaseNode.CloneableStatus.Single) { AddSourceError(new ErrorSingleTypeNotAllowed(node, EntityName.ValidText.Item)); Success = false; } } if (Success) { IScopeAttributeFeature NewEntity = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node); data = NewEntity; } return(Success); }
/// <summary> /// Checks for errors before applying a rule. /// </summary> /// <param name="node">The node instance to check.</param> /// <param name="dataList">Optional data collected during inspection of sources.</param> /// <param name="data">Private data to give to Apply() upon return.</param> /// <returns>True if an error occured.</returns> public override bool CheckConsistency(IAttributeFeature node, IDictionary <ISourceTemplate, object> dataList, out object data) { IObjectType TypeToResolve = (IObjectType)node.EntityType; IClass EmbeddingClass = node.EmbeddingClass; IScopeAttributeFeature ResultFeature = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node); data = ResultFeature; return(true); }
/// <summary> /// Checks for errors before applying a rule. /// </summary> /// <param name="node">The node instance to check.</param> /// <param name="dataList">Optional data collected during inspection of sources.</param> /// <param name="data">Private data to give to Apply() upon return.</param> /// <returns>True if an error occured.</returns> public override bool CheckConsistency(IIndexerFeature node, IDictionary <ISourceTemplate, object> dataList, out object data) { data = null; bool Success = true; IClass EmbeddingClass = node.EmbeddingClass; IObjectType TypeToResolve = (IObjectType)node.EntityType; IScopeAttributeFeature ResultFeature = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node); IScopeAttributeFeature ValueFeature = ScopeAttributeFeature.CreateValueFeature(TypeToResolve, EmbeddingClass, node); Success = CheckResultValueConsistency(node, dataList, ResultFeature, ValueFeature, out data); return(Success); }
/// <summary> /// Checks for errors before applying a rule. /// </summary> /// <param name="node">The node instance to check.</param> /// <param name="dataList">Optional data collected during inspection of sources.</param> /// <param name="data">Private data to give to Apply() upon return.</param> /// <returns>True if an error occured.</returns> public override bool CheckConsistency(IPropertyFeature node, IDictionary <ISourceTemplate, object> dataList, out object data) { data = null; bool Success = true; IClass EmbeddingClass = node.EmbeddingClass; IObjectType TypeToResolve = (IObjectType)node.EntityType; IScopeAttributeFeature Result = ScopeAttributeFeature.CreateResultFeature(TypeToResolve, EmbeddingClass, node); IScopeAttributeFeature Value = ScopeAttributeFeature.CreateValueFeature(TypeToResolve, EmbeddingClass, node); string NameResult = Result.ValidFeatureName.Item.Name; string NameValue = Value.ValidFeatureName.Item.Name; ISealableDictionary <string, IScopeAttributeFeature> CheckedGetScope = new SealableDictionary <string, IScopeAttributeFeature>(); CheckedGetScope.Add(NameResult, Result); ISealableDictionary <string, IScopeAttributeFeature> CheckedSetScope = new SealableDictionary <string, IScopeAttributeFeature>(); CheckedSetScope.Add(NameValue, Value); IList <string> ConflictList = new List <string>(); ScopeHolder.RecursiveCheck(CheckedGetScope, node.InnerScopes, ConflictList); ScopeHolder.RecursiveCheck(CheckedSetScope, node.InnerScopes, ConflictList); // This has been checked in another rule. Debug.Assert(!ConflictList.Contains(NameResult)); Debug.Assert(!ConflictList.Contains(NameValue)); IName PropertyName = (IName)((IFeatureWithName)node).EntityName; if (node.GetterBody.IsAssigned && node.SetterBody.IsAssigned) { ICompiledBody AsCompiledGetter = (ICompiledBody)node.GetterBody.Item; ICompiledBody AsCompiledSetter = (ICompiledBody)node.SetterBody.Item; if (AsCompiledGetter.IsDeferredBody != AsCompiledSetter.IsDeferredBody) { AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item)); Success = false; } if (node.PropertyKind != BaseNode.UtilityType.ReadWrite) { AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item)); Success = false; } } else if (node.GetterBody.IsAssigned) { if (node.PropertyKind == BaseNode.UtilityType.WriteOnly) { AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item)); Success = false; } } else if (node.SetterBody.IsAssigned) { if (node.PropertyKind == BaseNode.UtilityType.ReadOnly) { AddSourceError(new ErrorBodyTypeMismatch(node, PropertyName.ValidText.Item)); Success = false; } } if (Success) { data = new Tuple <IScopeAttributeFeature, IScopeAttributeFeature>(Result, Value); } return(Success); }