public IEnumerable<VerificationException> Verify(Library library) { // Parameters must be validated without access to parameter definitions, or expression definitions var initialContext = new VerificationContext(library.Models, library.Libraries, null, null, null, null, null); // Resolve parameter types and verify default expressions foreach (var parameter in library.Parameters) { try { parameter.ParameterType = initialContext.ResolveType(parameter.TypeName); if (parameter.Default != null) { Verifier.Verify(initialContext, parameter.Default); initialContext.VerifyType(parameter.Default.ResultType, parameter.ParameterType); } } catch (Exception e) { initialContext.ReportMessage(new VerificationException(String.Format("Exceptions occurred verifying parameter {0}.", parameter.Name), e), null); } } var context = new VerificationContext(library.Models, library.Libraries, library.Parameters, library.Expressions, library.CodeSystems, library.ValueSets, initialContext.Messages); // Verify expressions foreach (var expression in library.Expressions) { // If the result type is already set, this expression ref has already been resolved. if (expression.Expression.ResultType == null) { Verifier.Verify(context, expression.Expression); } } return context.Messages; }
public IEnumerable <VerificationException> Verify(Library library) { // Parameters must be validated without access to parameter definitions, or expression definitions var initialContext = new VerificationContext(library.Models, library.Libraries, null, null, null, null, null); // Resolve parameter types and verify default expressions foreach (var parameter in library.Parameters) { try { parameter.ParameterType = initialContext.ResolveType(parameter.TypeName); if (parameter.Default != null) { Verifier.Verify(initialContext, parameter.Default); initialContext.VerifyType(parameter.Default.ResultType, parameter.ParameterType); } } catch (Exception e) { initialContext.ReportMessage(new VerificationException(String.Format("Exceptions occurred verifying parameter {0}.", parameter.Name), e), null); } } var context = new VerificationContext(library.Models, library.Libraries, library.Parameters, library.Expressions, library.CodeSystems, library.ValueSets, initialContext.Messages); // Verify expressions foreach (var expression in library.Expressions) { // If the result type is already set, this expression ref has already been resolved. if (expression.Expression.ResultType == null) { Verifier.Verify(context, expression.Expression); } } return(context.Messages); }
public void Verify(VerificationContext context, ASTNode node) { Verifier.Verify(context, node.Children[0]); Verifier.Verify(context, node.Children[1]); var comparandType = node.Children[0].ResultType; context.VerifyType(node.Children[1].ResultType, comparandType); node.ResultType = comparandType; }
public void Verify(VerificationContext context, ASTNode node) { Verifier.Verify(context, node.Children[0]); context.VerifyType(node.Children[0].ResultType, DataTypes.Boolean); node.ResultType = DataTypes.Boolean; }
public void Verify(VerificationContext context, ASTNode node) { var comparand = node.Children.FirstOrDefault(n => n.Name == "comparand"); DataType comparisonType = null; if (comparand != null) { Verifier.Verify(context, comparand); comparisonType = comparand.ResultType; } else { comparisonType = DataTypes.Boolean; } DataType resultType = null; foreach (var caseItem in ((Node)node).Children.Where(n => n.Name == "caseItem")) { var when = caseItem.Children[0] as ASTNode; var then = caseItem.Children[1] as ASTNode; Verifier.Verify(context, when); context.VerifyType(when.ResultType, comparisonType); Verifier.Verify(context, then); if (resultType == null) { resultType = then.ResultType; if (resultType == null) { throw new InvalidOperationException("Could not determine result type for case expression based on then element of first case item."); } } else { context.VerifyType(then.ResultType, resultType); } } var elseNode = node.Children.FirstOrDefault(n => n.Name == "else") as ASTNode; if (elseNode != null) { Verifier.Verify(context, elseNode); context.VerifyType(elseNode.ResultType, resultType); } node.ResultType = resultType; }
public void Verify(VerificationContext context, ASTNode node) { var source = node.Children[0]; var condition = node.Children[1]; Verifier.Verify(context, source); var sourceListType = source.ResultType as ListType; if (sourceListType == null) { throw new InvalidOperationException("Filter expression source must be a list type expression."); } context.PushSymbol(new Symbol(node.GetAttribute<string>("scope", VerificationContext.Current), sourceListType.ElementType)); try { Verifier.Verify(context, condition); context.VerifyType(condition.ResultType, DataTypes.Boolean); } finally { context.PopSymbol(); } node.ResultType = sourceListType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var left = node.Children[0]; var right = node.Children[1]; var leftIntervalType = left.ResultType as IntervalType; if (leftIntervalType != null) { context.VerifyType(right.ResultType, leftIntervalType); node.ResultType = DataTypes.Boolean; } else { throw new InvalidOperationException("List type expected."); } }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var index = node.Children[1]; var sourceListType = source.ResultType as ListType; if (sourceListType != null) { node.ResultType = sourceListType.ElementType; } else { context.VerifyType(source.ResultType, DataTypes.String); node.ResultType = DataTypes.String; } context.VerifyType(index.ResultType, DataTypes.Integer); }
protected virtual void InternalVerify(VerificationContext context, ASTNode node, ObjectType dataType) { // idProperty - If present, must reference a property of type String (or explicitly convertible to string) on the resolved model type. var idProperty = node.GetAttribute<string>("idProperty"); if (!String.IsNullOrEmpty(idProperty)) { var idPropertyType = context.ResolveProperty(dataType, idProperty); if (!(DataTypes.Equivalent(idPropertyType, DataTypes.ResolveType(typeof(II))) || DataTypes.Equal(idPropertyType, DataTypes.String))) { throw new InvalidOperationException("Id property must be either an Identifier or a String."); } } // Validate children // timeOffset - If present, must evaluate to a value of type PIVL_TS var timeOffset = node.Children.Where(n => n.Name == "timeOffset").FirstOrDefault(); if (timeOffset != null) { Verifier.Verify(context, timeOffset); context.VerifyType(timeOffset.ResultType, DataTypes.ResolveType(typeof(PIVL_TS))); } }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var numerator = ((Node)node).Children[0]; var denominator = ((Node)node).Children[1]; var numeratorType = context.ResolveType(numerator.NodeType); var denominatorType = context.ResolveType(denominator.NodeType); context.VerifyType(numeratorType, DataTypes.Quantity); context.VerifyType(denominatorType, DataTypes.Quantity); node.ResultType = DataTypes.ResolveType(typeof(RTO)); }
protected override DataType GetResultType(VerificationContext context, ListType listType) { context.VerifyType(listType.ElementType, DataTypes.Boolean); return DataTypes.Boolean; }
public void Verify(VerificationContext context, ASTNode node) { // objectType var objectTypeName = node.GetAttribute<string>("classType"); if (objectTypeName != null) { var objectType = context.ResolveType(node.GetAttribute<string>("classType")) as ObjectType; // foreach property foreach (var child in ((Node)node).Children) { if (child.Name == "element") { // Verify the property exists var childPropertyType = context.ResolveProperty(objectType, child.GetAttribute<string>("name")); // Verify the value var value = (ASTNode)child.Children[0]; Verifier.Verify(context, value); // Verify the value type is appropriate for the property type context.VerifyType(value.ResultType, childPropertyType); } } node.ResultType = objectType; } else { var propertyList = new List<PropertyDef>(); foreach (var child in ((Node)node).Children) { if (child.Name == "element") { var value = (ASTNode)child.Children[0]; Verifier.Verify(context, value); var property = new PropertyDef(child.GetAttribute<string>("name"), value.ResultType); propertyList.Add(property); } } var objectType = new ObjectType(Guid.NewGuid().ToString(), propertyList); node.ResultType = objectType; } }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var element = node.Children[1]; var sourceListType = source.ResultType as ListType; if (sourceListType == null) { throw new InvalidOperationException("List type expected."); } context.VerifyType(element.ResultType, sourceListType.ElementType); node.ResultType = DataTypes.Integer; }
public IEnumerable<VerificationException> Verify(Artifact artifact) { // Parameters must be validated without access to parameter definitions, or expression definitions var initialContext = new VerificationContext(artifact.Models, null, null, null); // Resolve parameter types and verify default expressions foreach (var parameter in artifact.Parameters) { try { parameter.ParameterType = initialContext.ResolveType(parameter.TypeName); if (parameter.Default != null) { Verifier.Verify(initialContext, parameter.Default); initialContext.VerifyType(parameter.Default.ResultType, parameter.ParameterType); } } catch (Exception e) { initialContext.ReportMessage(new VerificationException(String.Format("Exceptions occurred verifying parameter {0}.", parameter.Name), e), null); } } var context = new VerificationContext(artifact.Models, artifact.Parameters, artifact.Expressions, initialContext.Messages); // Verify expressions foreach (var expression in artifact.Expressions) { // If the result type is already set, this expression ref has already been resolved. if (expression.Expression.ResultType == null) { Verifier.Verify(context, expression.Expression); } } // Verify conditions foreach (var condition in artifact.Conditions) { Verifier.Verify(context, condition); if (!DataTypes.Equal(condition.ResultType, DataTypes.Boolean)) { context.ReportMessage(new InvalidOperationException("Condition must evaluate to a value of type boolean."), condition); } } // Verify trigger expressions foreach (var trigger in artifact.Triggers) { VerifyExpressionNodes(context, trigger); } // Verify action conditions if (artifact.ActionGroup != null) { var containers = new Dictionary<string, ParameterDef>(); // Verify documentation template conditions and binding expressions VerifyResponseBindings(context, artifact.ActionGroup, containers); foreach (var parameter in containers.Values) { context.AddParameterDef(parameter); } VerifyExpressionNodes(context, artifact.ActionGroup); } return context.Messages; }
public void Verify(VerificationContext context, HeD.Engine.Model.ASTNode node) { Symbol sourceSymbol = null; // foreach source // add to the output context var sources = ((Node)node).Children.Where(c => c.Name == "source").ToList(); foreach (var source in sources) { if (sourceSymbol == null) { sourceSymbol = ProcessAliasedQuerySource(context, source); } else { throw new NotImplementedException("Multi-source query verification is not implemented."); } } if (sourceSymbol == null) { throw new InvalidOperationException("Could not determine query source type."); } var sourceSymbolListType = sourceSymbol.DataType as ListType; var sourceSymbolElementType = sourceSymbolListType != null ? sourceSymbolListType.ElementType : null; var sourceElementSymbol = sourceSymbolElementType != null ? new Symbol(sourceSymbol.Name, sourceSymbolElementType) : null; context.PushSymbol(sourceElementSymbol ?? sourceSymbol); try { // foreach define // add to the current scope var defines = ((Node)node).Children.Where(c => c.Name == "define").ToList(); foreach (var define in defines) { throw new NotImplementedException("Query defines are not implemented."); } // verify each with/without clause var relationships = ((Node)node).Children.Where(c => c.Name == "relationship").ToList(); foreach (var relationship in relationships) { var relatedSourceSymbol = ProcessAliasedQuerySource(context, relationship); var relatedSourceSymbolListType = relatedSourceSymbol.DataType as ListType; var relatedSourceSymbolElementType = relatedSourceSymbolListType != null ? relatedSourceSymbolListType.ElementType : null; var relatedSourceElementSymbol = relatedSourceSymbolElementType != null ? new Symbol(relatedSourceSymbol.Name, relatedSourceSymbolElementType) : null; context.PushSymbol(relatedSourceElementSymbol ?? relatedSourceSymbol); try { var suchThat = relationship.Children[1] as ASTNode; if (suchThat == null) { throw new InvalidOperationException(String.Format("Could not determine such that for relationship '{0}'.", relatedSourceSymbol.Name)); } Verifier.Verify(context, suchThat); context.VerifyType(suchThat.ResultType, DataTypes.Boolean); } finally { context.PopSymbol(); } } // verify the where clause var whereClause = ((Node)node).Children.Where(c => c.Name == "where").FirstOrDefault() as ASTNode; if (whereClause != null) { Verifier.Verify(context, whereClause); context.VerifyType(whereClause.ResultType, DataTypes.Boolean); } // verify the return clause var returnClause = ((Node)node).Children.Where(c => c.Name == "return").FirstOrDefault(); if (returnClause != null) { throw new NotImplementedException("Return clause is not implemented."); } // verify the sort clause var sortClause = ((Node)node).Children.Where(c => c.Name == "sort").FirstOrDefault(); if (sortClause != null) { throw new NotImplementedException("Sort clause is not implemented."); } node.ResultType = sourceSymbol.DataType; } finally { context.PopSymbol(); } }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); DataType operandType = null; foreach (var child in node.Children) { if (operandType == null) { operandType = child.ResultType; } else { context.VerifyType(child.ResultType, operandType); } } node.ResultType = operandType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var child = node.Children[0]; var intervalType = child.ResultType as IntervalType; if (intervalType != null) { var lengthOperator = context.ResolveCall("Subtract", new Signature(new DataType[] { intervalType.PointType, intervalType.PointType })); node.ResultType = lengthOperator.ResultType; } else { context.VerifyType(child.ResultType, DataTypes.String); node.ResultType = DataTypes.Integer; } }
public void Verify(VerificationContext context, ASTNode node) { // Verify source Verifier.Verify(context, node.Children[0]); var objectType = node.Children[0].ResultType as ObjectType; if (objectType == null) { throw new InvalidOperationException("The source expression for an object redefine must evaluate to a value of a structured type."); } // Push the source into context as a symbol context.PushSymbol(new Symbol(node.GetAttribute<string>("Scope", VerificationContext.Current), objectType)); try { // foreach property for (int i = 1; i < ((Node)node).Children.Count; i++) { // Verify the property exists var child = ((Node)node).Children[i]; var childPropertyType = context.ResolveProperty(objectType, child.GetAttribute<string>("name")); // Verify the value var value = (ASTNode)child.Children[0]; Verifier.Verify(context, value); // Verify the value type is appropriate for the property type context.VerifyType(value.ResultType, childPropertyType); } } finally { context.PopSymbol(); } node.ResultType = objectType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var source = node.Children[0]; var element = node.Children[1]; var sourceListType = source.ResultType as ListType; if (sourceListType != null) { context.VerifyType(element.ResultType, sourceListType.ElementType); node.ResultType = DataTypes.Boolean; } var sourceIntervalType = source.ResultType as IntervalType; if (sourceIntervalType != null) { context.VerifyType(element.ResultType, sourceIntervalType.PointType); node.ResultType = DataTypes.Boolean; } if (node.ResultType == null) { throw new InvalidOperationException("Expected an argument of type list or interval."); } }
protected override void InternalVerify(VerificationContext context, ASTNode node, ObjectType dataType) { base.InternalVerify(context, node, dataType); // codeProperty - If present, must reference a property of type Code on the resolved model type. var codeProperty = node.GetAttribute<string>("codeProperty"); if (!String.IsNullOrEmpty(codeProperty)) { var codePropertyType = context.ResolveProperty(dataType, codeProperty); context.VerifyType(codePropertyType, DataTypes.Code); } // dateProperty - If present, must reference a property of type Timestamp on the resolved model type. (TODO: Handle Interval<Timestamp>?) var dateProperty = node.GetAttribute<string>("dateProperty"); if (!String.IsNullOrEmpty(dateProperty)) { var datePropertyType = context.ResolveProperty(dataType, dateProperty); context.VerifyType(datePropertyType, DataTypes.DateTime); } // codes - If present, must evaluate to a value of type List<Code> var codes = node.Children.Where(n => n.Name == "codes").FirstOrDefault(); if (codes != null) { Verifier.Verify(context, codes); context.VerifyType(codes.ResultType, DataTypes.CodeList); } // dateRange - If present, must evaluate to a value of type Interval<Timestamp> var dateRange = node.Children.Where(n => n.Name == "dateRange").FirstOrDefault(); if (dateRange != null) { Verifier.Verify(context, dateRange); context.VerifyType(dateRange.ResultType, DataTypes.DateTimeInterval); } }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); if (node.Children.Count == 0) { throw new InvalidOperationException("Expected at least one child argument."); } DataType operandType = null; foreach (var child in node.Children) { if (operandType == null) { operandType = child.ResultType; if (!(operandType is ListType || operandType is IntervalType)) { throw new InvalidOperationException("List or interval type expected."); } } else { context.VerifyType(child.ResultType, operandType); } } node.ResultType = operandType; }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); foreach (var child in node.Children) { context.VerifyType(child.ResultType, GetOperandType()); } node.ResultType = GetResultType(); }
public IEnumerable <VerificationException> Verify(Artifact artifact) { // Parameters must be validated without access to parameter definitions, or expression definitions var initialContext = new VerificationContext(artifact.Models, null, null, null); // Resolve parameter types and verify default expressions foreach (var parameter in artifact.Parameters) { try { parameter.ParameterType = initialContext.ResolveType(parameter.TypeName); if (parameter.Default != null) { Verifier.Verify(initialContext, parameter.Default); initialContext.VerifyType(parameter.Default.ResultType, parameter.ParameterType); } } catch (Exception e) { initialContext.ReportMessage(new VerificationException(String.Format("Exceptions occurred verifying parameter {0}.", parameter.Name), e), null); } } var context = new VerificationContext(artifact.Models, artifact.Parameters, artifact.Expressions, initialContext.Messages); // Verify expressions foreach (var expression in artifact.Expressions) { // If the result type is already set, this expression ref has already been resolved. if (expression.Expression.ResultType == null) { Verifier.Verify(context, expression.Expression); } } // Verify conditions foreach (var condition in artifact.Conditions) { Verifier.Verify(context, condition); if (!DataTypes.Equal(condition.ResultType, DataTypes.Boolean)) { context.ReportMessage(new InvalidOperationException("Condition must evaluate to a value of type boolean."), condition); } } // Verify trigger expressions foreach (var trigger in artifact.Triggers) { VerifyExpressionNodes(context, trigger); } // Verify action conditions if (artifact.ActionGroup != null) { var containers = new Dictionary <string, ParameterDef>(); // Verify documentation template conditions and binding expressions VerifyResponseBindings(context, artifact.ActionGroup, containers); foreach (var parameter in containers.Values) { context.AddParameterDef(parameter); } VerifyExpressionNodes(context, artifact.ActionGroup); } return(context.Messages); }
protected override void InternalVerify(VerificationContext context, ASTNode node) { base.InternalVerify(context, node); var conditionNode = node.Children[0]; var thenNode = node.Children[1]; var elseNode = node.Children[2]; context.VerifyType(conditionNode.ResultType, DataTypes.Boolean); var resultType = thenNode.ResultType; if (resultType == null) { throw new InvalidOperationException("Could not determine type of then expression for conditional."); } context.VerifyType(elseNode.ResultType, resultType); node.ResultType = resultType; }