private static ExprBinaryOperator ProcessPredicateWithFullPath(Match match)
{
string fullPath = match.Groups["fullPath"].Value;
if (string.IsNullOrEmpty(fullPath))
{
throw new ApplicationException("fullPath must not be null or empty.");
}
PathExpr pathExpr = ToPathExpr(fullPath);
string standardExprOperator = match.Groups["predicate_path_operator"].Value;
OperatorKind operatorKind = new OperatorKind(OperatorKind.GetOperatorKind(standardExprOperator));
string predicateCriteria = match.Groups["predicate_criteria"].Value;
if (string.IsNullOrEmpty(predicateCriteria))
{
throw new ApplicationException("predicateCriteria must not be null or empty.");
}
object criteriaValue = null;
string type = GetCriteriaType(match, out criteriaValue);
ExprLeaf rightOperand = new ExprLeaf(criteriaValue, type, "constraint");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(pathExpr, rightOperand, type, operatorKind, false);
return(binaryOperator);
}
private static ExprBinaryOperator ProcessMatchesExpr(Match match)
{
string matches = match.Groups["matchesExpr"].Value;
if (string.IsNullOrEmpty(matches))
{
throw new ApplicationException("matches must not be null or empty.");
}
string leftPath = match.Groups["predicate_path"].Value;
ExprLeaf leftOperand = null;
if (string.IsNullOrEmpty(leftPath))
{
leftOperand = new ExprLeaf("/archetype_node_id", "String", "path");
}
else
{
leftOperand = new ExprLeaf(leftPath, "String", "path");
}
OperatorKind operatorKind = new OperatorKind(OperatorKind.op_matches);
string pattern = match.Groups["regex_pattern"].Value;
if (string.IsNullOrEmpty(pattern))
{
throw new ApplicationException("pattern must not be null or empty.");
}
ExprLeaf rightOperand = new ExprLeaf(pattern, "String", "pattern");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(leftOperand, rightOperand, rightOperand.Type, operatorKind, false);
return(binaryOperator);
}
private static ExprBinaryOperator ProcessStandardPredicateExpr(Match match)
{
string standardExpr = match.Groups["predicate_expre"].Value;
if (string.IsNullOrEmpty(standardExpr))
{
throw new ApplicationException("standardExpr must not be null or empty.");
}
string path = match.Groups["predicate_path"].Value;
if (string.IsNullOrEmpty(path))
{
throw new ApplicationException("predicate_path must not be null or empty");
}
ExprLeaf lefOperand = new ExprLeaf(path, "String", "Path");
string standardExprOperator = match.Groups["predicate_path_operator"].Value;
OperatorKind operatorKind = new OperatorKind(OperatorKind.GetOperatorKind(standardExprOperator));
// default value
object criteriaValue = null;
string type = GetCriteriaType(match, out criteriaValue);
ExprLeaf rightOperand = new ExprLeaf(criteriaValue, type, "constraint");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(lefOperand, rightOperand, type, operatorKind, false);
return(binaryOperator);
}
internal static ExprItem ExprItem(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
ExprItem exprItem = null;
switch (typeName)
{
case "EXPR_LEAF":
exprItem = new ExprLeaf();
break;
case "EXPR_UNARY_OPERATOR":
exprItem = new ExprUnaryOperator();
break;
case "EXPR_BINARY_OPERATOR":
exprItem = new ExprBinaryOperator();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(exprItem != null, "exprItem must not be null.");
return(exprItem);
}
internal static string AssertionRegExPattern(Assertion assertion)
{
Check.Require(assertion != null, "assertion must not be null.");
string assertionRegex = string.Empty;
ExprBinaryOperator expression = assertion.Expression as ExprBinaryOperator;
if (expression != null)
{
ExprLeaf rightExpression = expression.RightOperand as ExprLeaf;
if (rightExpression != null)
{
CString stringConstraint = rightExpression.Item as CString;
Check.Assert(stringConstraint != null);
Check.Assert(!string.IsNullOrEmpty(stringConstraint.Pattern));
Check.Assert(!(stringConstraint.Pattern.StartsWith("/") &&
stringConstraint.Pattern.EndsWith("/")), "Regex is enclosed in forward slashes, as with the C_STRING produced by old version of the ADL Parser.");
// Cleanse regex of fullstops which are not either preceded by a backslash (\.) or followed by a star (.*)
assertionRegex = stringConstraint.Pattern
.Replace(".*", " * ")
.Replace(@"\.", @" \ ")
.Replace(".", @"\.")
.Replace(@" \ ", @"\.")
.Replace(" * ", ".*");
}
}
return assertionRegex;
}
protected void Validate(ExprBinaryOperator binaryOperator)
{
this.ValidateBase((ExprOperator)binaryOperator);
Invariant(binaryOperator.LeftOperand != null,
string.Format(CommonStrings.XMustNotBeNull, "binaryOperator.LeftOperand"));
this.Validate(binaryOperator.LeftOperand);
Invariant(binaryOperator.RightOperand != null,
string.Format(CommonStrings.XMustNotBeNull, "binaryOperator.RightOperand"));
this.Validate(binaryOperator.RightOperand);
}
private static ExprBinaryOperator Map(this EXPR_BINARY_OPERATOR model)
{
var binary = new ExprBinaryOperator
{
IsPrecedenceOverriden = model.precedence_overridden,
Operator = (OperatorKind)((int)model.@operator),
LeftOperand = model.left_operand.Map(),
RightOperand = model.right_operand.Map()
};
return(binary);
}
internal string GetValueCriteriaByPath(ExprItem exprItem, string requiredPath)
{
ExprLeaf leaf = exprItem as ExprLeaf;
ExprBinaryOperator binary = exprItem as ExprBinaryOperator;
if (binary != null)
{
switch (binary.Operator.Value)
{
case OperatorKind.op_eq:
case OperatorKind.op_ne:
{
string path = GetPredicateFullPath(binary.LeftOperand);
if (path != null && path.EndsWith(requiredPath, StringComparison.InvariantCultureIgnoreCase))
{
ExprLeaf rightOperand = binary.RightOperand as ExprLeaf;
if (rightOperand == null)
{
throw new ApplicationException("rightOperand must be typeof ExprLeaf when the leftOperand is name/value path.");
}
if (!rightOperand.ReferenceType.Equals("constraint"))
{
throw new NotSupportedException(rightOperand.ReferenceType + "rightOperand.ReferenceType is not supported.");
}
return(rightOperand.Item.ToString());
}
return(null);
}
case OperatorKind.op_or:
case OperatorKind.op_and:
case OperatorKind.op_not:
ExprItem left = binary.LeftOperand;
ExprItem right = binary.RightOperand;
string nameValue = GetValueCriteriaByPath(right, requiredPath);
if (nameValue != null)
{
return(nameValue);
}
nameValue = GetValueCriteriaByPath(left, requiredPath);
return(nameValue);
default:
return(null);
}
}
return(null);
}
private static ExprBinaryOperator ProcessArchetypeNodeIdExpr(Match match)
{
string archetypeNodeId = match.Groups["archetype_node_id"].Value;
if (string.IsNullOrEmpty(archetypeNodeId))
{
throw new ApplicationException("archetypeNodeId must not be null or empty.");
}
ExprLeaf leftOperand = new ExprLeaf("/archetype_node_id", "String", "path");
ExprLeaf rightOperand = new ExprLeaf(archetypeNodeId, "String", "constraint");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(leftOperand, rightOperand, "String", new OperatorKind(OperatorKind.op_eq),
false);
return(binaryOperator);
}
private static ExprBinaryOperator ProcessShortCutName(Match match)
{
string shortCutNameExpr = match.Groups["shortCutName"].Value;
if (string.IsNullOrEmpty(shortCutNameExpr))
{
throw new ApplicationException("shortCutNameExpr must not be null or empty.");
}
string nameValue = match.Groups["stringCriteria"].Value;
ExprLeaf leftOperand = new ExprLeaf("/name/value", "String", "path");
ExprLeaf rightOperand = new ExprLeaf(nameValue, "String", "constraint");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(leftOperand, rightOperand, "String",
new OperatorKind(OperatorKind.op_eq), false);
return(binaryOperator);
}
private static ExprBinaryOperator ProcessBoolExpr(Match match)
{
string boolExprString = match.Groups["genericExpr"].Value;
if (string.IsNullOrEmpty(boolExprString))
{
throw new ApplicationException("boolExprString must not be null or empty.");
}
ExprBinaryOperator boolExpr = null;
string leftOperandString = match.Groups["leftSimpleExpr"].Value;
if (string.IsNullOrEmpty(leftOperandString))
{
throw new ApplicationException("leftOperandString must not be null or empty.");
}
ExprOperator leftOperand = ToExprOperator(leftOperandString);
do
{
if (boolExpr != null)
{
leftOperand = boolExpr;
}
string boolOperatorStr = match.Groups["predicate_bool_operator"].Value;
OperatorKind boolOperator = new OperatorKind(OperatorKind.GetOperatorKind(boolOperatorStr));
string rightOperandStr = match.Groups["rightSimpleExpr"].Value;
if (string.IsNullOrEmpty(rightOperandStr))
{
throw new ApplicationException("rightOperandStr must not be null or empty.");
}
ExprOperator rightOperand = ToExprOperator(rightOperandStr);
boolExpr = new ExprBinaryOperator(leftOperand, rightOperand, "Boolean", boolOperator, false);
match = match.NextMatch();
} while (match.Success);
DesignByContract.Check.Ensure(boolExpr != null, "boolExpr must not be null.");
return(boolExpr);
}
private static ExprBinaryOperator ProcessPositionExpr(Match match)
{
string positionString = match.Groups["position"].Value;
if (string.IsNullOrEmpty(positionString))
{
throw new ApplicationException("positionString must not be null or empty.");
}
int position = int.Parse(positionString);
if (position <= 0)
{
throw new ApplicationException("Position specified within openehr path must not <= 0.");
}
FunctionCall functionCall = new FunctionCall("position", null, null);
ExprLeaf rightOperand = new ExprLeaf(position, "Integer", "constraint");
ExprBinaryOperator binaryOperator = new ExprBinaryOperator(functionCall, rightOperand,
rightOperand.Type, new OperatorKind(OperatorKind.op_eq), false);
return(binaryOperator);
}
protected void Validate(ExprBinaryOperator binaryOperator)
{
this.ValidateBase((ExprOperator)binaryOperator);
Invariant(binaryOperator.LeftOperand != null,
string.Format(CommonStrings.XMustNotBeNull, "binaryOperator.LeftOperand"));
this.Validate(binaryOperator.LeftOperand);
Invariant(binaryOperator.RightOperand != null,
string.Format(CommonStrings.XMustNotBeNull, "binaryOperator.RightOperand"));
this.Validate(binaryOperator.RightOperand);
}
internal static ExprItem ExprItem(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
ExprItem exprItem = null;
switch (typeName)
{
case "EXPR_LEAF":
exprItem = new ExprLeaf();
break;
case "EXPR_UNARY_OPERATOR":
exprItem = new ExprUnaryOperator();
break;
case "EXPR_BINARY_OPERATOR":
exprItem = new ExprBinaryOperator();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(exprItem != null, "exprItem must not be null.");
return exprItem;
}
private void WriteXml(ExprBinaryOperator exprBinaryOperator)
{
Check.Require(exprBinaryOperator != null, string.Format(CommonStrings.XMustNotBeNull, "exprBinaryOperator"));
Check.Require(exprBinaryOperator.LeftOperand != null, string.Format(CommonStrings.XMustNotBeNull, "exprBinaryOperator.LeftOperand"));
Check.Require(exprBinaryOperator.RightOperand != null, string.Format(CommonStrings.XMustNotBeNull, "exprBinaryOperator.RightOperand"));
this.WriteXmlBase((ExprOperator)exprBinaryOperator);
writer.WriteStartElement(UseOpenEhrPrefix(writer), "left_operand", OpenEhrNamespace);
string leftOperandType = AmType.GetName(exprBinaryOperator.LeftOperand);
writer.WriteAttributeString(UseXsiPrefix(writer), "type", XsiNamespace, leftOperandType);
this.WriteXml(exprBinaryOperator.LeftOperand);
writer.WriteEndElement();
writer.WriteStartElement(UseOpenEhrPrefix(writer), "right_operand", OpenEhrNamespace);
string rightOperandType = AmType.GetName(exprBinaryOperator.RightOperand);
writer.WriteAttributeString(UseXsiPrefix(writer), "type", XsiNamespace, rightOperandType);
this.WriteXml(exprBinaryOperator.RightOperand);
writer.WriteEndElement();
}
private void ReadXml(ExprBinaryOperator exprBinaryOperator)
{
reader.ReadStartElement();
reader.MoveToContent();
this.ReadXmlBase((ExprOperator)exprBinaryOperator);
if (reader.LocalName != "left_operand")
throw new InvalidXmlException("left_operand" + reader.LocalName);
string leftOperandType = reader.GetAttribute("type", XsiNamespace);
Check.Assert(!string.IsNullOrEmpty(leftOperandType), "leftOperandType must not be null or empty.");
exprBinaryOperator.LeftOperand = AmFactory.ExprItem(leftOperandType);
this.ReadXml(exprBinaryOperator.LeftOperand);
if (reader.LocalName != "right_operand")
throw new InvalidXmlException("right_operand" + reader.LocalName);
string rightOperandType = reader.GetAttribute("type", XsiNamespace);
Check.Assert(!string.IsNullOrEmpty(rightOperandType), "rightOperandType must not be null or empty.");
exprBinaryOperator.RightOperand = AmFactory.ExprItem(rightOperandType);
this.ReadXml(exprBinaryOperator.RightOperand);
DesignByContract.Check.Assert(reader.NodeType == System.Xml.XmlNodeType.EndElement,
"Expected endElement of AssertionVairable");
reader.ReadEndElement();
reader.MoveToContent();
}