private string GetXmlFragmentForLocation(string location) { var xpathToGetAllIIisConfigurationByLocation = string.Format("//*[@Location = \"{0}\"]", location); var allIisProperties = new XPathOperator().applyXpath(MetabaseFileContent, xpathToGetAllIIisConfigurationByLocation, true); return(string.Join(Environment.NewLine, allIisProperties)); }
private static bool Compare(XPathOperator xPathOperator, object left, object right) { if (!(left is IComparable comparable)) { throw new Exception($"Cannot evaluate {xPathOperator} operator, value on the left side does not implement IComparable interface."); } var result = comparable.CompareTo(right); switch (xPathOperator) { case XPathOperator.Eq: return(result == 0); case XPathOperator.Ge: return(result > 0 || result == 0); case XPathOperator.Gt: return(result > 0); case XPathOperator.Le: return(result < 0 || result == 0); case XPathOperator.Lt: return(result < 0); case XPathOperator.Ne: return(result != 0); } throw new NotImplementedException("Unknown operator " + xPathOperator); }
private string ToOperatorMethodName(XPathOperator xPathOperator) { switch (xPathOperator) { case XPathOperator.Divide: return("op_Division"); case XPathOperator.Minus: return("op_Subtraction"); case XPathOperator.Modulo: return("op_Modulus"); case XPathOperator.Multiply: return("op_Multiply"); case XPathOperator.Plus: return("op_Addition"); case XPathOperator.UnaryMinus: return("op_UnaryNegation"); } return(null); }
private MetabaseSessionConfiguration GetMetabasePropertyFromMBSchema(string id) { var xpathExpression = string.Format("//*[@ID='{0}']", id); try { var propertyNode = new XPathOperator().applyXpath(XmlMBSchema, xpathExpression, true).FirstOrDefault(); if (!string.IsNullOrEmpty(propertyNode)) { var name = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "InternalName", true); var type = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Type", true); var userType = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "UserType", true); return(new MetabaseSessionConfiguration(name, id, type, userType)); } return(null); } catch (XPathNoResultException) { try { var propertyNode = new XPathOperator().applyXpath(XmlMetabaseContent, xpathExpression, true).FirstOrDefault(); var name = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Name", false); var type = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "Type", false); var userType = TryToGetAttributeValueFromMetabaseFragment(propertyNode, "UserType", false); return(new MetabaseSessionConfiguration(name, id, type, userType)); } catch (XPathNoResultException) { return(null); } } }
private string TryToGetAttributeValueFromMetabaseFragment(string metabaseXmlFragment, string attributeName, bool retryToGetValue) { var xPathOperator = new XPathOperator(); try { var xpathExpression = string.Format("//*/@{0}", attributeName); return(xPathOperator.applyXpath(metabaseXmlFragment, xpathExpression).FirstOrDefault()); } catch (XPathNoResultException) { try { if (retryToGetValue) { return(xPathOperator.applyXpath(metabaseXmlFragment, "//*/@Value").FirstOrDefault()); } return(null); } catch (XPathNoResultException) { return(null); } } }
public XPathPredicate(string left, XPathOperator op, string right) { this.Left = left; this.Operator = op; this.Right = Regex.Replace(right, @"^'|'$", ""); this.RightFormatted = right; }
public virtual QilNode Operator(XPathOperator op, QilNode?left, QilNode?right) { Debug.Assert(op != XPathOperator.Unknown); XPathOperatorGroup opGroup = s_operatorGroup[(int)op]; Debug.Assert((opGroup != XPathOperatorGroup.Negate && right != null) || (opGroup == XPathOperatorGroup.Negate && right == null)); switch (opGroup) { case XPathOperatorGroup.Logical: return(LogicalOperator(op, left !, right !)); case XPathOperatorGroup.Equality: return(EqualityOperator(op, left !, right !)); case XPathOperatorGroup.Relational: return(RelationalOperator(op, left !, right !)); case XPathOperatorGroup.Arithmetic: return(ArithmeticOperator(op, left !, right !)); case XPathOperatorGroup.Negate: return(NegateOperator(op, left !)); case XPathOperatorGroup.Union: return(UnionOperator(op, left, right !)); default: Debug.Fail($"{op} is not a valid XPathOperator"); return(null); } }
private QilNode CompareValues(XPathOperator op, QilNode left, QilNode right, XmlTypeCode compType) { Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String); Debug.Assert(compType == XmlTypeCode.Boolean || left.XmlType.IsSingleton && right.XmlType.IsSingleton, "Both comparison operands must be singletons"); left = _f.ConvertToType(compType, left); right = _f.ConvertToType(compType, right); switch (op) { case XPathOperator.Eq: return(_f.Eq(left, right)); case XPathOperator.Ne: return(_f.Ne(left, right)); case XPathOperator.Lt: return(_f.Lt(left, right)); case XPathOperator.Le: return(_f.Le(left, right)); case XPathOperator.Gt: return(_f.Gt(left, right)); case XPathOperator.Ge: return(_f.Ge(left, right)); default: Debug.Fail("Wrong operator type"); return(null); } }
private QilNode EqualityOperator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Eq || op == XPathOperator.Ne); XmlQueryType leftType = left.XmlType; XmlQueryType rightType = right.XmlType; if (_f.IsAnyType(left) || _f.IsAnyType(right)) { return(_f.InvokeEqualityOperator(s_qilOperator[(int)op], left, right)); } else if (leftType.IsNode && rightType.IsNode) { return(CompareNodeSetAndNodeSet(op, left, right, XmlTypeCode.String)); } else if (leftType.IsNode) { return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*val:*/ right, rightType.TypeCode)); } else if (rightType.IsNode) { return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*val:*/ left, leftType.TypeCode)); } else { XmlTypeCode compType = ( leftType.TypeCode == XmlTypeCode.Boolean || rightType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean : leftType.TypeCode == XmlTypeCode.Double || rightType.TypeCode == XmlTypeCode.Double ? XmlTypeCode.Double : /*default:*/ XmlTypeCode.String ); return(CompareValues(op, left, right, compType)); } }
private QilNode RelationalOperator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Lt || op == XPathOperator.Le || op == XPathOperator.Gt || op == XPathOperator.Ge); XmlQueryType leftType = left.XmlType; XmlQueryType rightType = right.XmlType; if (_f.IsAnyType(left) || _f.IsAnyType(right)) { return(_f.InvokeRelationalOperator(s_qilOperator[(int)op], left, right)); } else if (leftType.IsNode && rightType.IsNode) { return(CompareNodeSetAndNodeSet(op, left, right, XmlTypeCode.Double)); } else if (leftType.IsNode) { XmlTypeCode compType = rightType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean : XmlTypeCode.Double; return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*val:*/ right, compType)); } else if (rightType.IsNode) { XmlTypeCode compType = leftType.TypeCode == XmlTypeCode.Boolean ? XmlTypeCode.Boolean : XmlTypeCode.Double; op = InvertOp(op); return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*val:*/ left, compType)); } else { return(CompareValues(op, left, right, XmlTypeCode.Double)); } }
public XPathPredicate(IXPathOperand left, XPathOperator op, IXPathOperand right) { this.Left = left; this.Operator = op; this.Right = right; this.RightFormatted = right.ToString(); }
public XElement Operator(XPathOperator op, XElement left, XElement right) { if (op == XPathOperator.UnaryMinus) { return(new XElement("negate", left)); } return(new XElement(op.ToString(), left, right)); }
private QilNode CompareNodeSetAndValue(XPathOperator op, QilNode nodeset, QilNode val, XmlTypeCode compType) { _f.CheckNodeSet(nodeset); Debug.Assert(val.XmlType !.IsSingleton); Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String, "I don't know what to do with RTF here"); if (compType == XmlTypeCode.Boolean || nodeset.XmlType !.IsSingleton) { return(CompareValues(op, nodeset, val, compType)); }
public string Operator(XPathOperator op, string left, string right) { Debug.Assert(op != XPathOperator.Union); if (op == XPathOperator.UnaryMinus) { return("-" + left); } return(left + opStrings[(int)op] + right); }
public static string GetOperatorString(XPathOperator op) { switch (op) { case XPathOperator.Eq: return("="); } throw new Exception("Unhandled XPathOperator"); }
private QilNode LogicalOperator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Or || op == XPathOperator.And); left = _f.ConvertToBoolean(left); right = _f.ConvertToBoolean(right); return( op == XPathOperator.Or ? _f.Or(left, right) : /*default*/ _f.And(left, right) ); }
// Inverts relational operator in order to swap operands of the comparison private static XPathOperator InvertOp(XPathOperator op) { return( op == XPathOperator.Lt ? XPathOperator.Gt : // '<' --> '>' op == XPathOperator.Le ? XPathOperator.Ge : // '<=' --> '>=' op == XPathOperator.Gt ? XPathOperator.Lt : // '>' --> '<' op == XPathOperator.Ge ? XPathOperator.Le : // '>=' --> '<=' /*default:*/ op ); }
/* * EqualityExpr ::= RelationalExpr (('=' | '!=') RelationalExpr)* */ private Node ParseEqualityExpr() { Node opnd = ParseRelationalExpr(); bool eq; while ((eq = scanner.Kind == LexKind.Eq) || scanner.Kind == LexKind.Ne) { XPathOperator op = eq ? XPathOperator.Eq : XPathOperator.Ne; scanner.NextLex(); opnd = builder.Operator(op, opnd, ParseRelationalExpr()); } return(opnd); }
/* * AdditiveExpr ::= MultiplicativeExpr (('+' | '-') MultiplicativeExpr)* */ private Node ParseAdditiveExpr() { Node opnd = ParseMultiplicativeExpr(); bool plus; while ((plus = scanner.Kind == LexKind.Plus) || scanner.Kind == LexKind.Minus) { XPathOperator op = plus ? XPathOperator.Plus : XPathOperator.Minus; scanner.NextLex(); opnd = builder.Operator(op, opnd, ParseMultiplicativeExpr()); } return(opnd); }
public QilNode Operator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Union); Debug.Assert(left != null); Debug.Assert(right != null); // It is important to not create nested lists here Debug.Assert(right.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter"); if (left.NodeType == QilNodeType.Sequence) { ((QilList)left).Add(right); return left; } else { Debug.Assert(left.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter"); return f.Sequence(left, right); } }
private QilNode CompareNodeSetAndValue(XPathOperator op, QilNode nodeset, QilNode val, XmlTypeCode compType) { _f.CheckNodeSet(nodeset); Debug.Assert(val.XmlType.IsSingleton); Debug.Assert(compType == XmlTypeCode.Boolean || compType == XmlTypeCode.Double || compType == XmlTypeCode.String, "I don't know what to do with RTF here"); if (compType == XmlTypeCode.Boolean || nodeset.XmlType.IsSingleton) { return(CompareValues(op, nodeset, val, compType)); } else { QilIterator it = _f.For(nodeset); return(_f.Not(_f.IsEmpty(_f.Filter(it, CompareValues(op, _f.XPathNodeValue(it), val, compType))))); } }
public object Operator(XPathOperator op, object left, object right) { switch (op) { case XPathOperator.Eq: return(EqOperator(left, right)); case XPathOperator.And: return(AndOperator(left, right)); case XPathOperator.Or: return(OrOperator(left, right)); } throw new NotSupportedException($"Operator {op.ToString()} is not supported."); }
public object Operator(XPathOperator op, object left, object right) { if (op == XPathOperator.Eq) { if (left is AutomationProperty property) { return(new CompareFunc((elem, index) => { var propValue = elem.GetCurrentPropertyValue(property, true); if (propValue != null) { return propValue.Equals(right); } return false; })); } else if (left is UiAutomationElement en) { if (UiAutomationElement.ProgrammaticName == en) { return(new CompareFunc((elem, index) => { string propValue = elem.Current.ControlType?.ProgrammaticName.Replace("ControlType.", ""); if (propValue != null) { return propValue.Equals(right); } return false; })); } if (UiAutomationElement.Id == en) { return(new CompareFunc((elem, index) => { int?propValue = elem.Current.ControlType?.Id; if (propValue.HasValue) { return propValue.ToString().Equals(right); } return false; })); } } } throw new NotSupportedException($"Operator {op.ToString()} is not supported."); }
public QilNode Operator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Union); Debug.Assert(left != null); Debug.Assert(right != null); // It is important to not create nested lists here Debug.Assert(right.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter"); if (left.NodeType == QilNodeType.Sequence) { ((QilList)left).Add(right); return(left); } else { Debug.Assert(left.NodeType == QilNodeType.Filter, "LocationPathPattern must be compiled into a filter"); return(_f.Sequence(left, right)); } }
private QilNode CompareNodeSetAndNodeSet(XPathOperator op, QilNode left, QilNode right, XmlTypeCode compType) { _f.CheckNodeSet(left); _f.CheckNodeSet(right); if (right.XmlType.IsSingleton) { return(CompareNodeSetAndValue(op, /*nodeset:*/ left, /*value:*/ right, compType)); } if (left.XmlType.IsSingleton) { op = InvertOp(op); return(CompareNodeSetAndValue(op, /*nodeset:*/ right, /*value:*/ left, compType)); } QilIterator leftEnd = _f.For(left); QilIterator rightEnd = _f.For(right); return(_f.Not(_f.IsEmpty(_f.Loop(leftEnd, _f.Filter(rightEnd, CompareValues(op, _f.XPathNodeValue(leftEnd), _f.XPathNodeValue(rightEnd), compType)))))); }
public string Operator(XPathOperator op, string left, string right) { Debug.Assert(op != XPathOperator.Union); if (op == XPathOperator.UnaryMinus) { return("-" + left); } if (left.StartsWith("attribute::")) { left = left.Remove(0, "attribute::".Length); } lastPredicate = new XPathPredicate(left, op, right); return(left + opStrings[(int)op] + right); }
private QilNode UnionOperator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Union); if (left == null) { return(_f.EnsureNodeSet(right)); } left = _f.EnsureNodeSet(left); right = _f.EnsureNodeSet(right); if (left.NodeType == QilNodeType.Sequence) { ((QilList)left).Add(right); return(left); } else { return(_f.Union(left, right)); } }
QilNode UnionOperator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op == XPathOperator.Union); if (left == null) { return(f.EnsureNodeSet(right)); } left = f.EnsureNodeSet(left); right = f.EnsureNodeSet(right); if (left.NodeType == QilNodeType.Sequence) { // ToDo: drop this logic or move it to QilPatternFactory.Union() ((QilList)left).Add(right); return(left); } else { return(f.Union(left, right)); } }
private QilNode ArithmeticOperator(XPathOperator op, QilNode left, QilNode right) { left = _f.ConvertToNumber(left); right = _f.ConvertToNumber(right); switch (op) { case XPathOperator.Plus: return(_f.Add(left, right)); case XPathOperator.Minus: return(_f.Subtract(left, right)); case XPathOperator.Multiply: return(_f.Multiply(left, right)); case XPathOperator.Divide: return(_f.Divide(left, right)); case XPathOperator.Modulo: return(_f.Modulo(left, right)); default: Debug.Fail("Wrong operator type"); return(null); } }
public virtual QilNode Operator(XPathOperator op, QilNode left, QilNode right) { Debug.Assert(op != XPathOperator.Unknown); switch (s_operatorGroup[(int)op]) { case XPathOperatorGroup.Logical: return(LogicalOperator(op, left, right)); case XPathOperatorGroup.Equality: return(EqualityOperator(op, left, right)); case XPathOperatorGroup.Relational: return(RelationalOperator(op, left, right)); case XPathOperatorGroup.Arithmetic: return(ArithmeticOperator(op, left, right)); case XPathOperatorGroup.Negate: return(NegateOperator(op, left, right)); case XPathOperatorGroup.Union: return(UnionOperator(op, left, right)); default: Debug.Fail(op + " is not a valid XPathOperator"); return(null); } }
private void CheckFlaggedProperties(MetabaseSessionConfiguration metabaseSession) { if (string.IsNullOrWhiteSpace(metabaseSession.Value)) { return; } if (this.IsFlaggedProperty(metabaseSession)) { int propertyValue = 0; var flags = metabaseSession.Value.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); foreach (var flag in flags) { var xPathFlagNode = string.Format("//*[@InternalName='{0}']", flag.Trim()); var flagNode = new XPathOperator().applyXpath(this.XmlMBSchema, xPathFlagNode, true); var flagValue = int.Parse(new XPathOperator().applyXpath(flagNode.First(), "//*/@Value", false).First()); propertyValue += flagValue; } metabaseSession.Value = propertyValue.ToString(); } }