/************************************************************************************************************/ public static string Operater_to_str(RelationalOperator opt) { if (opt == RelationalOperator.Equals) { return("="); } if (opt == RelationalOperator.GreaterThan) { return(">"); } if (opt == RelationalOperator.LessThan) { return("<"); } if (opt == RelationalOperator.NotEqual) { return("!="); } if (opt == RelationalOperator.Greater_or_Equals) { return(">="); } if (opt == RelationalOperator.Less_or_Equals) { return("<="); } return(null); }
/// <summary> /// For statement other than 'in', like =,>,< /// </summary> /// <param name="colName">column name</param> /// <param name="opt">operater</param> /// <param name="val_str">value in string</param> /// <returns></returns> private string Init_RO(string colName, RelationalOperator opt, string val_str) { StringBuilder sb = new StringBuilder(); if (string.IsNullOrEmpty(colName)) { return(null); } sb.Append('[').Append(colName.Replace("]", "]]")).Append(']'); if (val_str == null) { if (opt == RelationalOperator.Equals) { sb.Append(" is NULL "); } else { sb.Append(" is not NULL "); } } else { sb.Append(' ').Append(SQL_relation.Operater_to_str(opt)).Append(' '); sb.Append("'").Append(val_str.Replace("'", "''")).Append("'"); } return(sb.ToString()); }
public PropertyComparerPredicate(PropertyDescriptor property, string value, RelationalOperator op) { if (property == null) { throw new ArgumentNullException("property"); } if (op == RelationalOperator.None) { throw new ArgumentException("op"); } this.property = property; if (value == null) { this.compareTo = default(T); } else { this.compareTo = (T)property.Converter.ConvertFrom(value); } this.op = op; this.comparer = Comparer <T> .Default; }
public RelationalUserDataFilter(Guid userProfile, string userDataKey, RelationalOperator op, string filterValue, bool includeEmpty = false) : base(userProfile, userDataKey) { _operator = op; _filterValue = filterValue; _includeEmpty = includeEmpty; }
public RelationalOperation(TypeExpression secondOperand, RelationalOperator relationalOperator, MethodType methodAnalyzed, bool showErrorMessage, Location location) { this.secondOperand = secondOperand; this.relationalOperator = relationalOperator; this.methodAnalyzed = methodAnalyzed; this.showErrorMessage = showErrorMessage; this.location = location; }
public ConstraintData( Expression expr, RelationalOperator op, double strength) { m_expression=Constraint.reduce(expr); m_strength=Strength.clip(strength); m_op=op; }
public WithCondition(string navigationPropertyPath, RelationalOperator operatorTag, Expression <Func <TEntity, bool> > predicate) { NavigationPropertyPath = navigationPropertyPath; RelationalOperator = operatorTag; Predicate = predicate; }
public void Deconstruct(out string navigationPropertyPath, out RelationalOperator operatorTag, out Expression <Func <TEntity, bool> > predicate, out bool needTracking) { navigationPropertyPath = NavigationPropertyPath; operatorTag = RelationalOperator; predicate = Predicate; needTracking = NeedTracking; }
public RelationalType MakeRelational(RelationalOperator op, ArithmeticExpression lhs, ArithmeticExpression rhs) { RelationalType newRelational = new RelationalType(); newRelational.AddLHSArithmeticExpression(lhs); newRelational.AddRelationalOperator(op); newRelational.AddRHSArithmeticExpression(rhs); return(newRelational); }
bool IsValidRelational(ArithmeticExpression lhs, ArithmeticExpression rhs, RelationalOperator op, VariableType type) { bool valid1; bool valid2; VariableType t1 = ValidateArithmeticExpression(lhs, out valid1); VariableType t2 = ValidateArithmeticExpression(rhs, out valid2); return(IsTypeCompatible(t1, t2, out type) && valid1 && valid2); }
public override int GetHashCode() { var hashCode = -572934366; hashCode = hashCode * -1521134295 + EqualityComparer <JoinColumn> .Default.GetHashCode(LeftColumn); hashCode = hashCode * -1521134295 + EqualityComparer <JoinColumn> .Default.GetHashCode(RightColumn); hashCode = hashCode * -1521134295 + RelationalOperator.GetHashCode(); hashCode = hashCode * -1521134295 + LogicalOperator.GetHashCode(); return(hashCode); }
public RelationalExpression(string prop, string value, RelationalOperator op) { if (prop == null) throw new ArgumentNullException("prop"); if (prop == "") throw new ArgumentException("prop"); if (value == null) throw new ArgumentNullException("value"); if (op == RelationalOperator.None) throw new ArgumentException("op"); this.prop = prop; this.value = value; this.op = op; }
public static KeyValuePair <string, bool> ConvertToString(RelationalOperator relationalOperator) { switch (relationalOperator) { case RelationalOperator.BETWEEN: return(new KeyValuePair <string, bool>("between {0} and {1}", false)); case RelationalOperator.Equal: return(new KeyValuePair <string, bool>("=", true)); case RelationalOperator.Exists: return(new KeyValuePair <string, bool>("Exists({0})", false)); case RelationalOperator.GreaterEqualThan: return(new KeyValuePair <string, bool>(">=", true)); case RelationalOperator.GreaterThan: return(new KeyValuePair <string, bool>(">", true)); case RelationalOperator.IN: return(new KeyValuePair <string, bool>("in({0})", false)); case RelationalOperator.LessEqualThan: return(new KeyValuePair <string, bool>("<=", true)); case RelationalOperator.LessThan: return(new KeyValuePair <string, bool>("<", true)); case RelationalOperator.LIKE: return(new KeyValuePair <string, bool>("like '%{0}%'", false)); case RelationalOperator.NotEqual: return(new KeyValuePair <string, bool>("<>", true)); case RelationalOperator.StartLike: return(new KeyValuePair <string, bool>("like '{0}%'", false)); case RelationalOperator.EndLike: return(new KeyValuePair <string, bool>("like '%{0}'", false)); default: return(new KeyValuePair <string, bool>("", true)); } }
protected override void GenerateOperator(BinaryExpression node, TypeExpression result) { RelationalOperator relationalOperator = ((RelationalExpression)node).Operator; switch (relationalOperator) { case RelationalOperator.NotEqual: this.codeGenerator.ceq(this.indent); this.codeGenerator.ldc(this.indent, false); this.codeGenerator.ceq(this.indent); break; case RelationalOperator.Equal: this.codeGenerator.ceq(this.indent); break; case RelationalOperator.LessThan: this.codeGenerator.clt(this.indent); break; case RelationalOperator.GreaterThan: this.codeGenerator.cgt(this.indent); break; case RelationalOperator.LessThanOrEqual: this.codeGenerator.cgt(this.indent); this.codeGenerator.ldc(this.indent, false); this.codeGenerator.ceq(this.indent); break; case RelationalOperator.GreaterThanOrEqual: this.codeGenerator.clt(this.indent); this.codeGenerator.ldc(this.indent, false); this.codeGenerator.ceq(this.indent); break; default: // Error this.codeGenerator.Comment("ERROR"); break; } // if (!IsValueType(node.ExpressionType) && !(node.ExpressionType is StringType)) // this.codeGenerator.Box(indent, BoolType.Instance); }
public static string GetOpeatorText(this RelationalOperator op) { switch (op) { case RelationalOperator.Equal: return("=="); case RelationalOperator.NotEqual: return("!="); case RelationalOperator.Less: return("<"); case RelationalOperator.Greater: return(">"); case RelationalOperator.LessOrEqual: return("<="); case RelationalOperator.GreaterOrEqual: return(">="); } throw new InvalidOperationException("Not supported operator"); }
public static RelationalOperator Negate(this RelationalOperator op) { switch (op) { case RelationalOperator.Equal: return(RelationalOperator.NotEqual); case RelationalOperator.NotEqual: return(RelationalOperator.Equal); case RelationalOperator.Less: return(RelationalOperator.GreaterOrEqual); case RelationalOperator.Greater: return(RelationalOperator.LessOrEqual); case RelationalOperator.LessOrEqual: return(RelationalOperator.Greater); case RelationalOperator.GreaterOrEqual: return(RelationalOperator.Less); } throw new InvalidOperationException("Not supported operand"); }
private string TranslateOperator(RelationalOperator op) { switch (op) { case RelationalOperator.GT: return(">"); case RelationalOperator.GE: return(">="); case RelationalOperator.LT: return("<"); case RelationalOperator.LE: return("<="); case RelationalOperator.EQ: return("="); case RelationalOperator.NE: return("!="); default: return(string.Empty); } }
public override IType VisitRelational([NotNull] FAILangParser.RelationalContext context) { if (context.binary().Length == 1) { return(VisitBinary(context.binary(0))); } var binaryNodes = context.binary(); var ops = context.relational_op(); RelationalOperator[] opers = new RelationalOperator[ops.Length]; for (int i = 0; i < opers.Length; i++) { switch (ops[i].GetText()) { case "=": opers[i] = RelationalOperator.EQUALS; break; case "~=": opers[i] = RelationalOperator.NOT_EQUALS; break; case ">": opers[i] = RelationalOperator.GREATER; break; case "<": opers[i] = RelationalOperator.LESS; break; case ">=": opers[i] = RelationalOperator.GREATER_EQUAL; break; case "<=": opers[i] = RelationalOperator.LESS_EQUAL; break; } } return(new RelationalOperatorExpression(opers, binaryNodes.Select(x => VisitBinary(x)).ToArray())); }
public StringComparerPredicate(PropertyDescriptor property, string value, RelationalOperator op) { if (property == null) throw new ArgumentNullException("property"); this.property = property; this.compareTo = value; if (compareTo != null && compareTo.IndexOfAny(new char[] { '%', '*' }) > -1) { StringBuilder expr = new StringBuilder(); expr.Append("^"); foreach (char c in compareTo) { if (c == '*' || c == '%') expr.Append(".*"); else expr.Append(c); } this.exp = new Regex(expr.ToString(), RegexOptions.IgnoreCase); } this.op = op; }
public RelationalExpression(string prop, string value, RelationalOperator op) { if (prop == null) { throw new ArgumentNullException("prop"); } if (prop == "") { throw new ArgumentException("prop"); } if (value == null) { throw new ArgumentNullException("value"); } if (op == RelationalOperator.None) { throw new ArgumentException("op"); } this.prop = prop; this.value = value; this.op = op; }
public LogicalExpression MakeRelationalExperssion(string op, ArithmeticExpression lhs, ArithmeticExpression rhs) { RelationalOperator relationalOp = new RelationalOperator(); if (op == "==") { relationalOp.AddEquals(new Altova.Types.SchemaString("Equals")); } else if (op == "!=") { relationalOp.AddNotEquals(new Altova.Types.SchemaString("NotEquals")); } else if (op == "<") { relationalOp.AddLessThan(new Altova.Types.SchemaString("LessThan")); } else if (op == "<=") { relationalOp.AddLessThanOrEquals(new Altova.Types.SchemaString("LessThanOrEquals")); } else if (op == ">") { relationalOp.AddGreaterThan(new Altova.Types.SchemaString("GreaterThan")); } else if (op == "<=") { relationalOp.AddGreaterThanOrEquals(new Altova.Types.SchemaString("GreaterThanOrEquals")); } RelationalType relationalExpression = MakeRelational(relationalOp, lhs, rhs); LogicalExpression newLogical = new LogicalExpression(); newLogical.AddRelational(relationalExpression); return(newLogical); }
/// <summary> /// Applies the concrete relational operator to evaluate logical value. /// </summary> /// <param name="relOperator">Relational operator.</param> /// <param name="leftValue">Left value.</param> /// <param name="rightValue">Right value.</param> /// <returns>True if the concrete operation evaluates as true, false otherwise.</returns> public static bool ApplyCompare(RelationalOperator relOperator, double leftValue, double rightValue) { switch (relOperator) { case RelationalOperator.LT: return(leftValue < rightValue); case RelationalOperator.LTE: return(leftValue <= rightValue); case RelationalOperator.GT: return(leftValue > rightValue); case RelationalOperator.GTE: return(leftValue >= rightValue); case RelationalOperator.EQ: return(leftValue.Equals(rightValue)); default: Debug.Assert(false, "Unknown operator!"); return(false); } }
/// <summary> /// Gets the string representation of the relational operator. /// </summary> /// <param name="relOperator">Relational operator.</param> /// <returns>String representation of the operator.</returns> public static string ToString(RelationalOperator relOperator) { switch (relOperator) { case RelationalOperator.LT: return("<"); case RelationalOperator.LTE: return("<="); case RelationalOperator.GT: return(">"); case RelationalOperator.GTE: return(">="); case RelationalOperator.EQ: return("="); default: Debug.Assert(false, "Unknown operator!"); return("?"); } }
public RelationalFilter(MediaItemAspectMetadata.AttributeSpecification attributeType, RelationalOperator op, object filterValue) : base(attributeType) { _operator = op; _filterValue = filterValue; }
private DataFilter CreateDataFilter(string filter, string sortBy, string sortOrder) { DataFilter dataFilter = new DataFilter(); // process filtering if (filter != null && filter.Count() > 0) { try { JavaScriptSerializer serializer = new JavaScriptSerializer(); List <Dictionary <String, String> > filterExpressions = (List <Dictionary <String, String> >)serializer.Deserialize(filter, typeof(List <Dictionary <String, String> >)); if (filterExpressions != null && filterExpressions.Count > 0) { List <Expression> expressions = new List <Expression>(); dataFilter.Expressions = expressions; foreach (Dictionary <String, String> expr in filterExpressions) { Expression expression = new Expression(); expressions.Add(expression); if (expr.ContainsKey("conjunction")) // new filter { if (expr["conjunction"] != null) { if (expr["conjunction"].Length == 0) { expression.LogicalOperator = LogicalOperator.None; } else { expression.LogicalOperator = (LogicalOperator) Enum.Parse(typeof(LogicalOperator), expr["conjunction"]); } } expression.RelationalOperator = (RelationalOperator) Enum.Parse(typeof(RelationalOperator), expr["operator"]); } else // legacy ux filter { if (expressions.Count > 1) { expression.LogicalOperator = LogicalOperator.And; } if (expr.ContainsKey("comparison") && expr["comparison"] != null) { //expression.RelationalOperator = (RelationalOperator) //Enum.Parse(typeof(RelationalOperator), expr["comparison"]); RelationalOperator optor = GetOpt(expr["comparison"]); expression.RelationalOperator = optor; } else { expression.RelationalOperator = RelationalOperator.EqualTo; } } expression.PropertyName = expr["field"]; Values values = new Values(); expression.Values = values; string value = expr["value"]; values.Add(value); } } } catch (Exception ex) { _logger.Error("Error deserializing filter: " + ex); //response = response + " " + ex.Message.ToString(); CustomErrorLog objCustomErrorLog = new CustomErrorLog(); _CustomError = objCustomErrorLog.customErrorLogger(ErrorMessages.errUIGridPages, ex, _logger); response = response + " " + throwJsonResponse(_CustomError); } } // process sorting if (sortBy != null && sortBy.Count() > 0 && sortOrder != null && sortOrder.Count() > 0) { List <OrderExpression> orderExpressions = new List <OrderExpression>(); dataFilter.OrderExpressions = orderExpressions; OrderExpression orderExpression = new OrderExpression(); orderExpressions.Add(orderExpression); if (sortBy != null) { orderExpression.PropertyName = sortBy; } string sortOrderEnumVal = sortOrder.Substring(0, 1).ToUpper() + sortOrder.Substring(1).ToLower(); if (sortOrderEnumVal != null) { try { orderExpression.SortOrder = (SortOrder)Enum.Parse(typeof(SortOrder), sortOrderEnumVal); } catch (Exception ex) { _logger.Error(ex.ToString()); // response = response + " " + ex.Message.ToString(); CustomErrorLog objCustomErrorLog = new CustomErrorLog(); _CustomError = objCustomErrorLog.customErrorLogger(ErrorMessages.errUIGridPages, ex, _logger); response = response + " " + throwJsonResponse(_CustomError); } } } return(dataFilter); }
public RelationalUserDataFilter(Guid userProfile, string userDataKey, RelationalOperator op, string filterValue) : base(userProfile, userDataKey) { _operator = op; _filterValue = filterValue; }
internal RelationalExpression(ConditionExpression left, ConditionExpression right, RelationalOperator binaryOperator) : base(left, right) { _operator = binaryOperator; }
public RelationalExpression(Expression left, Expression right, RelationalOperator @operator) : base(left, right) { Operator = @operator; }
public RelationalExpression(AbstractRelationalExpression relationalExpression, RelationalOperator relationalOperator, AbstractShiftExpression shiftExpression, bool isStrictMode) : base(isStrictMode) { this.relationalExpression = relationalExpression; this.relationalOperator = relationalOperator; this.shiftExpression = shiftExpression; }
string GetLogicalExpressionString(LogicalExpression exp) { string retVal = ""; if (exp.HasUnary()) { retVal = GetLogicalExpressionString(exp.GetUnary().GetLogicalExpression()); } else if (exp.HasRelational()) { RelationalOperator op = exp.GetRelational().GetRelationalOperator(); string lhs = GetArithmeticExpressionString(exp.GetRelational().GetLHSArithmeticExpression()); string rhs = GetArithmeticExpressionString(exp.GetRelational().GetRHSArithmeticExpression()); string opString = ""; if (op.HasEquals()) { opString = "=="; } else if (op.HasNotEquals()) { opString = "!="; } else if (op.HasPartOf()) { opString = "partof"; } else if (op.HasNotPartOf()) { opString = "notpartof"; } else if (op.HasLessThan()) { opString = "<"; } else if (op.HasLessThanOrEquals()) { opString = "<="; } else if (op.HasGreaterThan()) { opString = ">"; } else if (op.HasGreaterThanOrEquals()) { opString = ">="; } retVal = lhs + " " + opString + " " + rhs; } else if (exp.HasLogical()) { string lhs = GetLogicalExpressionString(exp.GetLogical().GetLHSLogicalExpression()); string rhs = GetLogicalExpressionString(exp.GetLogical().GetRHSLogicalExpression()); string opString; if (exp.GetLogical().GetLogicalOperator().HasAnd()) { opString = "and"; } else //OR { opString = "or"; } retVal = lhs + " " + opString + " " + rhs; } else if (exp.HasValue()) { if (exp.GetValue().HasConstant()) { if ((bool)exp.GetValue().GetConstant().GetBoolean().Value) { retVal = "true"; } else { retVal = "false"; } } else { retVal = exp.GetValue().GetVariable().GetName().Value; } } return(retVal); }
bool EvaluateLogicalExpression(LogicalExpression exp) { bool retVal = false; if (exp.HasUnary()) { retVal = EvaluateLogicalExpression(exp.GetUnary().GetLogicalExpression()); } else if (exp.HasRelational()) { RelationalOperator op = exp.GetRelational().GetRelationalOperator(); ConstantType lhs = EvaluateArithmeticExpression(exp.GetRelational().GetLHSArithmeticExpression()); ConstantType rhs = EvaluateArithmeticExpression(exp.GetRelational().GetRHSArithmeticExpression()); if (op.HasEquals()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { retVal = ((bool)lhs.GetBoolean().Value == (bool)rhs.GetBoolean().Value); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value == (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value == (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { string lhsString = (string)lhs.GetString2().Value; string rhsString = (string)rhs.GetString2().Value; retVal = (lhsString == rhsString); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value == (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value == (float)rhs.GetInteger().Value); } } } else if (op.HasNotEquals()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { retVal = ((bool)lhs.GetBoolean().Value != (bool)rhs.GetBoolean().Value); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value != (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value != (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { retVal = (lhs.GetString2() != rhs.GetString2()); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value != (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value != (float)rhs.GetInteger().Value); } } } else if (op.HasPartOf()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { retVal = ((bool)lhs.GetBoolean().Value == (bool)rhs.GetBoolean().Value); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value == (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value == (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { retVal = (lhs.GetString2() == rhs.GetString2()); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value == (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value == (float)rhs.GetInteger().Value); } } } else if (op.HasNotPartOf()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { retVal = ((bool)lhs.GetBoolean().Value != (bool)rhs.GetBoolean().Value); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value != (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value != (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { retVal = (lhs.GetString2().Value != rhs.GetString2().Value); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value != (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value != (float)rhs.GetInteger().Value); } } } else if (op.HasLessThan()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { throw new InvalidRuleException("Incompatible types in expression"); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value < (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value < (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { retVal = String.Compare(lhs.GetString2().Value, rhs.GetString2().Value, true) == -1; } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value < (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value < (float)rhs.GetInteger().Value); } } } else if (op.HasLessThanOrEquals()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { throw new InvalidRuleException("Incompatible types in expression"); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value <= (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value <= (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { int result = String.Compare(lhs.GetString2().Value, rhs.GetString2().Value); retVal = (result == -1) || (result == 0); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value <= (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value <= (float)rhs.GetInteger().Value); } } } else if (op.HasGreaterThan()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { throw new InvalidRuleException("Incompatible types in expression"); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value > (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value > (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { retVal = String.Compare(lhs.GetString2().Value, rhs.GetString2().Value, true) == 1; } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value > (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value > (float)rhs.GetInteger().Value); } } } else if (op.HasGreaterThanOrEquals()) { if (lhs.HasBoolean() && rhs.HasBoolean()) { throw new InvalidRuleException("Incompatible types in expression"); } else if (lhs.HasInteger()) { if (rhs.HasInteger()) { retVal = ((int)lhs.GetInteger().Value >= (int)rhs.GetInteger().Value); } else if (rhs.HasFloat2()) { retVal = ((int)lhs.GetInteger().Value >= (int)rhs.GetFloat2().Value); } } else if (lhs.HasString2() && rhs.HasString2()) { int result = String.Compare(lhs.GetString2().Value, rhs.GetString2().Value, true); retVal = (result == 1) || (result == 0); } else if (lhs.HasFloat2()) { if (rhs.HasFloat2()) { retVal = ((float)lhs.GetFloat2().Value >= (float)rhs.GetFloat2().Value); } else if (rhs.HasInteger()) { retVal = ((float)lhs.GetFloat2().Value >= (float)rhs.GetInteger().Value); } } } } else if (exp.HasLogical()) { bool lhs = EvaluateLogicalExpression(exp.GetLogical().GetLHSLogicalExpression()); bool rhs = EvaluateLogicalExpression(exp.GetLogical().GetRHSLogicalExpression()); if (exp.GetLogical().GetLogicalOperator().HasAnd()) { retVal = lhs && rhs; } else//OR { retVal = lhs || rhs; } } else if (exp.HasValue()) { if (exp.GetValue().HasConstant()) { retVal = exp.GetValue().GetConstant().GetBoolean().Value; } else { string currName = exp.GetValue().GetVariable().GetName().Value; Variable variable; if (m_Context.GetState().GetVariable(currName, out variable)) { retVal = (bool)variable.GetValue(); } } } return(retVal); }
public RelationalBranchDecision(RelationalOperator op, int operand) { this.Operator = op; this.Operand = operand; }
private static string BuildExpression <T>(string expression, int count, out object value) where T : class { value = null; foreach (string symbol in RelationalOperatorExtension.Symbols) { string[] parts = expression.Split(new[] { symbol }, StringSplitOptions.None).Select(p => p.Trim()) .ToArray(); if (parts.Length > 1) { string property = parts[0]; string openParenthesis = ""; while (property.StartsWith("(")) { property = property.Substring(1); openParenthesis += "("; } string strValue = parts[1]; string closeParenthesis = ""; while (strValue.EndsWith(")")) { strValue = strValue.Remove(strValue.Length - 1); closeParenthesis += ")"; } RelationalOperator relationalOperator = RelationalOperatorExtension.GetOperator(symbol); if (relationalOperator == RelationalOperator.Contains) { string[] cleanValues = Regex.Replace(strValue, @"^(\[|\(){1}(.*?)(\]|\)){1}$", "$2") .Split(',').Select(p => p.Trim('\'', ' ')).ToArray(); IList listValues; PropertyInfo propertyInfo = typeof(T).GetProperty(property); if (propertyInfo != null) { listValues = (IList)Activator.CreateInstance( typeof(List <>).MakeGenericType(propertyInfo.PropertyType)); foreach (string cleanValue in cleanValues) { listValues.Add(Convert.ChangeType(cleanValue, propertyInfo.PropertyType)); } value = listValues; } else { listValues = new List <string>(); foreach (string cleanValue in cleanValues) { listValues.Add(cleanValue); } value = listValues; } return(new StringBuilder().Append(openParenthesis).Append("@").Append(count) .Append(".Contains(outerIt.").Append(property).Append(")").Append(closeParenthesis) .ToString()); } else { string cleanValue = strValue.Trim('\'', ' '); PropertyInfo propertyInfo = typeof(T).GetProperty(property); if (propertyInfo != null) { value = Convert.ChangeType(cleanValue, propertyInfo.PropertyType); } else { value = cleanValue; } if (relationalOperator == RelationalOperator.Like || relationalOperator == RelationalOperator.StartsWith) { string method = "Contains"; if (relationalOperator == RelationalOperator.StartsWith) { method = "StartsWith"; } return(new StringBuilder().Append(openParenthesis).Append("it.").Append(property) .Append(".").Append(method).Append("(@").Append(count).Append(")") .Append(closeParenthesis) .ToString()); } return(new StringBuilder().Append(openParenthesis).Append(property).Append(" ") .Append(symbol).Append(" ").Append("@" + count).Append(closeParenthesis).ToString()); } } } return(null); }
public RelationalFilter(MediaItemAspectMetadata.AttributeSpecification attributeType, RelationalOperator op, object filterValue) : base(attributeType) { _operator = op; _filterValue = filterValue; }
/// <summary> /// Constructor of RelationalExpression /// </summary> /// <param name="operand1">First operand.</param> /// <param name="operand2">Second operand.</param> /// <param name="op">Operator of the binary expression.</param> /// <param name="fileName">File name.</param> /// <param name="lineNumber">Line number.</param> /// <param name="columnNumber">Column number.</param> public RelationalExpression(Expression operand1, Expression operand2, RelationalOperator op, Location location) : base(operand1, operand2, location) { this.op = op; }