/************************************************************************************************************/
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;
}
