public static RuleExpressionResult Evaluate(RuleExecution execution, CodeExpression expression)
{
if (execution == null)
{
throw new ArgumentNullException("execution");
}
RuleExpressionInternal ruleExpr = GetExpression(expression);
return(ruleExpr.Evaluate(expression, execution));
}
public static void AnalyzeUsage(RuleAnalysis analysis, CodeExpression expression, bool isRead, bool isWritten, RulePathQualifier qualifier)
{
if (analysis == null)
{
throw new ArgumentNullException("analysis");
}
RuleExpressionInternal ruleExpr = GetExpression(expression);
ruleExpr.AnalyzeUsage(expression, analysis, isRead, isWritten, qualifier);
}
public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten)
{
if (validation == null)
{
throw new ArgumentNullException("validation");
}
// See if we've visited this node before.
// Always check if written = true
RuleExpressionInfo resultExprInfo = null;
if (!isWritten)
{
resultExprInfo = validation.ExpressionInfo(expression);
}
if (resultExprInfo == null)
{
// First time we've seen this node.
RuleExpressionInternal ruleExpr = GetExpression(expression);
if (ruleExpr == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, expression.GetType().FullName);
ValidationError error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled);
error.UserData[RuleUserDataKeys.ErrorObject] = expression;
if (validation.Errors == null)
{
string typeName = string.Empty;
if ((validation.ThisType != null) && (validation.ThisType.Name != null))
{
typeName = validation.ThisType.Name;
}
string exceptionMessage = string.Format(
CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, typeName);
throw new InvalidOperationException(exceptionMessage);
}
else
{
validation.Errors.Add(error);
}
return(null);
}
resultExprInfo = validation.ValidateSubexpression(expression, ruleExpr, isWritten);
}
return(resultExprInfo);
}
public static CodeExpression Clone(CodeExpression originalExpression)
{
if (originalExpression == null)
{
return(null);
}
RuleExpressionInternal ruleExpr = GetExpression(originalExpression);
CodeExpression newExpr = ruleExpr.Clone(originalExpression);
ConditionHelper.CloneUserData(originalExpression, newExpr);
return(newExpr);
}
public static bool Match(CodeExpression firstExpression, CodeExpression secondExpression)
{
// If they're both null, they match.
if (firstExpression == null && secondExpression == null)
{
return(true);
}
// If only one of them is null, there's no match.
if (firstExpression == null || secondExpression == null)
{
return(false);
}
if (firstExpression.GetType() != secondExpression.GetType())
{
return(false);
}
RuleExpressionInternal ruleExpr1 = GetExpression(firstExpression);
return(ruleExpr1.Match(firstExpression, secondExpression));
}
public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten)
{
if (validation == null)
{
throw new ArgumentNullException("validation");
}
RuleExpressionInfo info = null;
if (!isWritten)
{
info = validation.ExpressionInfo(expression);
}
if (info != null)
{
return(info);
}
RuleExpressionInternal ruleExpr = GetExpression(expression);
if (ruleExpr == null)
{
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression.GetType().FullName }), 0x548);
item.UserData["ErrorObject"] = expression;
if (validation.Errors == null)
{
string name = string.Empty;
if ((validation.ThisType != null) && (validation.ThisType.Name != null))
{
name = validation.ThisType.Name;
}
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, new object[] { name }));
}
validation.Errors.Add(item);
return(null);
}
return(validation.ValidateSubexpression(expression, ruleExpr, isWritten));
}
internal TypeWrapperTuple(Type type, RuleExpressionInternal internalExpression)
{
this.codeDomType = type;
this.internalExpression = internalExpression;
}
internal TypeWrapperTuple(Type type, RuleExpressionInternal internalExpression)
{
this.codeDomType = type;
this.internalExpression = internalExpression;
}
internal RuleExpressionInfo ValidateSubexpression(CodeExpression expr, RuleExpressionInternal ruleExpr, bool isWritten)
{
RuleExpressionInfo info = ruleExpr.Validate(expr, this, isWritten);
if (info != null)
{
this.expressionInfoMap[expr] = info;
}
return info;
}
internal RuleExpressionInfo ValidateSubexpression(CodeExpression expr, RuleExpressionInternal ruleExpr, bool isWritten)
{
Debug.Assert(ruleExpr != null, "Validation::ValidateSubexpression - IRuleExpression is null");
Debug.Assert(expr != null, "Validation::ValidateSubexpression - CodeExpression is null");
RuleExpressionInfo exprInfo = ruleExpr.Validate(expr, this, isWritten);
if (exprInfo != null)
{
// Add the CodeExpression object to the info map. We don't want to add the IRuleExpression guy
// as the key, since it might likely be just a tearoff wrapper.
expressionInfoMap[expr] = exprInfo;
}
return exprInfo;
}
public static void Decompile(StringBuilder stringBuilder, CodeExpression expression, CodeExpression parentExpression)
{
RuleExpressionInternal ruleExpr = GetExpression(expression);
ruleExpr.Decompile(expression, stringBuilder, parentExpression);
}
