public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
IList <object> values = new List <object>();
foreach (var p in parameters)
{
var value = p.Evaluate(this.Variables);
var enumerable = value as IEnumerable;
if (enumerable != null)
{
foreach (var item in enumerable)
{
values.Add(item);
}
}
else
{
values.Add(value);
}
}
var groups = values.GroupBy(v => v);
int maxCount = groups.Max(g => g.Count());
return(groups.First(g => g.Count() == maxCount).Key);
}
/// <summary>
/// Initializes a new instance of the <see cref="Expression"/> class with the specified options.
/// </summary>
/// <param name="expression">The expression to be evaluated.</param>
/// <param name="options">The options to use when evaluating.</param>
public Expression(string expression, ExpressiveOptions options)
{
_originalExpression = expression;
_options = options;
_parser = new ExpressionParser(_options);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
var objectToConvert = parameters[0].Evaluate(Variables);
// No point converting if there is nothing to convert.
if (objectToConvert == null)
{
return(null);
}
// Safely check for a format parameter.
if (parameters.Length > 1)
{
var format = parameters[1].Evaluate(Variables);
if (format is string formatString)
{
return(string.Format($"{{0:{formatString}}}", objectToConvert));
}
}
return(objectToConvert.ToString());
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 3, 3);
object value = parameters[0].Evaluate(Variables);
if (value == null)
{
return(null);
}
// Safely handle the text input, if not text then call ToString.
string text = null;
if (value is string)
{
text = (string)value;
}
else
{
text = value.ToString();
}
int startIndex = (int)parameters[1].Evaluate(Variables);
int length = (int)parameters[2].Evaluate(Variables);
return(text?.Substring(startIndex, length));
}
/// <summary>
/// Initializes a new instance of the <see cref="Expression"/> class with the specified options.
/// </summary>
/// <param name="expression">The expression to be evaluated.</param>
/// <param name="options">The options to use when evaluating.</param>
public Expression(string expression, ExpressiveOptions options = ExpressiveOptions.None)
{
this.originalExpression = expression;
this.options = options;
this.parser = new ExpressionParser(this.options);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
object result = 0;
IList <decimal> decimalValues = new List <decimal>();
foreach (var p in parameters)
{
var value = p.Evaluate(this.Variables);
var enumerable = value as IEnumerable;
if (enumerable != null)
{
foreach (var item in enumerable)
{
decimalValues.Add(Convert.ToDecimal(item));
}
}
else
{
decimalValues.Add(Convert.ToDecimal(value));
}
}
return(Median(decimalValues.ToArray()));
}
internal BinaryExpression(BinaryExpressionType type, IExpression lhs, IExpression rhs, ExpressiveOptions options)
{
_expressionType = type;
_leftHandSide = lhs;
_options = options;
_rightHandSide = rhs;
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
int count = 0;
foreach (var value in parameters)
{
int increment = 1;
object evaluatedValue = value.Evaluate(Variables);
IEnumerable enumerable = evaluatedValue as IEnumerable;
if (enumerable != null)
{
int enumerableCount = 0;
foreach (var item in enumerable)
{
enumerableCount++;
}
increment = enumerableCount;
}
count += increment;
}
return(count);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
var objectToConvert = parameters[0].Evaluate(this.Variables);
// No point converting if there is nothing to convert.
if (objectToConvert == null)
{
return(null);
}
// Safely check for a format parameter.
if (parameters.Length > 1 &&
objectToConvert is string dateString)
{
var format = parameters[1].Evaluate(this.Variables);
if (format is string formatString)
{
return(DateTime.ParseExact(dateString, formatString, CultureInfo.CurrentCulture));
}
}
return(Convert.ToDateTime(objectToConvert));
}
internal ExpressionParser(ExpressiveOptions options)
{
this.context = new Context(options);
this.tokeniser = new Tokeniser(
this.context,
new List <ITokenExtractor>
{
new KeywordTokenExtractor(this.context.FunctionNames),
new KeywordTokenExtractor(this.context.OperatorNames),
// Variables
new ParenthesisedTokenExtractor('[', ']'),
new NumericTokenExtractor(),
// Dates
new ParenthesisedTokenExtractor('#'),
new ValueTokenExtractor(","),
new ParenthesisedTokenExtractor('"'),
new ParenthesisedTokenExtractor('\''),
// TODO: Probably a better way to achieve this.
new ValueTokenExtractor("true"),
new ValueTokenExtractor("TRUE"),
new ValueTokenExtractor("false"),
new ValueTokenExtractor("FALSE"),
new ValueTokenExtractor("null"),
new ValueTokenExtractor("NULL")
});
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
object result = 0;
foreach (var value in parameters)
{
object evaluatedValue = value.Evaluate(Variables);
IEnumerable enumerable = evaluatedValue as IEnumerable;
if (enumerable != null)
{
object enumerableSum = 0;
foreach (var item in enumerable)
{
// When summing we don't want to bail out early with a null value.
enumerableSum = Numbers.Add(enumerableSum ?? 0, item ?? 0);
}
evaluatedValue = enumerableSum;
}
// When summing we don't want to bail out early with a null value.
result = Numbers.Add(result ?? 0, evaluatedValue ?? 0);
}
return(result);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 1);
int count = 0;
object result = 0;
foreach (var value in parameters)
{
int increment = 1;
object evaluatedValue = value.Evaluate(Variables);
IEnumerable enumerable = evaluatedValue as IEnumerable;
if (enumerable != null)
{
int enumerableCount = 0;
object enumerableSum = 0;
foreach (var item in enumerable)
{
enumerableCount++;
enumerableSum = Numbers.Add(enumerableSum, item);
}
increment = enumerableCount;
evaluatedValue = enumerableSum;
}
result = Numbers.Add(result, evaluatedValue);
count += increment;
}
return(Convert.ToDouble(result) / count);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 3, 3);
bool condition = Convert.ToBoolean(parameters[0].Evaluate(Variables));
return(condition ? parameters[1].Evaluate(Variables) : parameters[2].Evaluate(Variables));
}
public static void TestWithNoMatchingValueByCase(ExpressiveOptions option)
{
var extractor = new ValueTokenExtractor("Match");
var token = extractor.ExtractToken("match", 0, new Context(option));
Assert.IsNull(token);
}
#pragma warning restore 618
public static void TestWithMatchingValueIgnoringCase(ExpressiveOptions option)
{
var extractor = new ValueTokenExtractor("match");
var token = extractor.ExtractToken("MaTcH", 0, new Context(option));
Assert.IsNotNull(token);
Assert.AreEqual("match", token.CurrentToken);
}
public static void TestStringComparisonIgnoreCase(
ExpressiveOptions expressiveOptions,
StringComparison expectedEqualityStringComparison,
StringComparison expectedParsingStringComparison)
{
var context = new Context(expressiveOptions);
Assert.That(context.EqualityStringComparison, Is.EqualTo(expectedEqualityStringComparison));
Assert.That(context.ParsingStringComparison, Is.EqualTo(expectedParsingStringComparison));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 3, 3);
string text = (string)parameters[0].Evaluate(Variables);
int startIndex = (int)parameters[1].Evaluate(Variables);
int length = (int)parameters[2].Evaluate(Variables);
// Not very safe at present but let's see for now.
return(text.Substring(startIndex, length));
}
public static FunctionSet CreateDefault(ExpressiveOptions options)
{
if ((options & ExpressiveOptions.IgnoreCaseForParsing) > 0)
{
return(CreateDefaultSet(StringComparer.OrdinalIgnoreCase));
}
else
{
return(CreateDefaultSet(StringComparer.Ordinal));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Context"/> class with the specified <paramref name="options"/>.
/// </summary>
/// <param name="options">The <see cref="ExpressiveOptions"/> to use when evaluating.</param>
/// <param name="mainCurrentCulture">The <see cref="CultureInfo"/> for use in general parsing/conversions.</param>
/// <param name="decimalCurrentCulture">The <see cref="CultureInfo"/> for use in decimal parsing/conversions.</param>
public Context(ExpressiveOptions options, CultureInfo mainCurrentCulture, CultureInfo decimalCurrentCulture, FunctionSet functions, OperatorSet operators)
{
Options = options;
this.CurrentCulture = mainCurrentCulture ?? throw new ArgumentNullException(nameof(mainCurrentCulture));
// For now we will ignore any specific cultures but keeping it in a single place to simplify changing later if required.
this.DecimalCurrentCulture = decimalCurrentCulture ?? throw new ArgumentNullException(nameof(decimalCurrentCulture));
DecimalSeparator = Convert.ToChar(this.DecimalCurrentCulture.NumberFormat.NumberDecimalSeparator, this.DecimalCurrentCulture);
this.registeredFunctions = functions ?? throw new ArgumentNullException(nameof(functions));
this.registeredOperators = operators ?? throw new ArgumentNullException(nameof(operators));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 1, 1);
var objectToConvert = parameters[0].Evaluate(Variables);
// No point converting if there is nothing to convert.
if (objectToConvert == null)
{
return(null);
}
return(Convert.ToInt32(objectToConvert));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
string text = (string)parameters[0].Evaluate(Variables);
string value = (string)parameters[1].Evaluate(Variables);
if (value == null)
{
return(false);
}
return(text?.StartsWith(value, options.HasFlag(ExpressiveOptions.IgnoreCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == true);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 1, 1);
var dateObject = parameters[0].Evaluate(this.Variables);
if (dateObject == null)
{
return(null);
}
DateTime date = Convert.ToDateTime(dateObject);
return(date.Month);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 1, 1);
var value = parameters[0].Evaluate(Variables);
if (value is double)
{
return(Math.Ceiling((double)value));
}
else if (value is decimal)
{
return(Math.Ceiling((decimal)value));
}
return(Math.Ceiling(Convert.ToDouble(value)));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 1, 1);
var value = parameters[0].Evaluate(Variables);
if (value != null)
{
var valueType = TypeHelper.GetTypeCode(value);
switch (valueType)
{
case TypeCode.Decimal:
return(Math.Abs(Convert.ToDecimal(value)));
case TypeCode.Double:
return(Math.Abs(Convert.ToDouble(value)));
case TypeCode.Int16:
return(Math.Abs(Convert.ToInt16(value)));
case TypeCode.UInt16:
return(Math.Abs(Convert.ToUInt16(value)));
case TypeCode.Int32:
return(Math.Abs(Convert.ToInt32(value)));
case TypeCode.UInt32:
return(Math.Abs(Convert.ToUInt32(value)));
case TypeCode.Int64:
return(Math.Abs(Convert.ToInt64(value)));
case TypeCode.SByte:
return(Math.Abs(Convert.ToSByte(value)));
case TypeCode.Single:
return(Math.Abs(Convert.ToSingle(value)));
default:
break;
}
}
return(null);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
var startObject = parameters[0].Evaluate(Variables);
var endObject = parameters[1].Evaluate(Variables);
if (startObject == null || endObject == null)
{
return(null);
}
DateTime start = Convert.ToDateTime(startObject);
DateTime end = Convert.ToDateTime(endObject);
return((end - start).TotalHours);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
var dateObject = parameters[0].Evaluate(Variables);
var millisecondsObject = parameters[1].Evaluate(Variables);
if (dateObject == null || millisecondsObject == null)
{
return(null);
}
DateTime date = Convert.ToDateTime(dateObject);
double milliseconds = Convert.ToDouble(millisecondsObject);
return(date.AddMilliseconds(milliseconds));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
var dateObject = parameters[0].Evaluate(this.Variables);
var yearsObject = parameters[1].Evaluate(this.Variables);
if (dateObject == null || yearsObject == null)
{
return(null);
}
DateTime date = Convert.ToDateTime(dateObject);
int years = Convert.ToInt32(yearsObject);
return(date.AddYears(years));
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, -1, 2);
bool found = false;
object parameter = parameters[0].Evaluate(Variables);
// Goes through any values, and stop whe one is found
for (int i = 1; i < parameters.Length; i++)
{
if (Comparison.CompareUsingMostPreciseType(parameter, parameters[i].Evaluate(Variables), options.HasFlag(ExpressiveOptions.IgnoreCase)) == 0)
{
found = true;
break;
}
}
return(found);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
string text = (string)parameters[0].Evaluate(Variables);
string value = (string)parameters[1].Evaluate(Variables);
if (value == null)
{
return(false);
}
if (options.HasFlag(ExpressiveOptions.IgnoreCase))
{
text = text?.ToLower();
value = value?.ToLower();
}
// Not very safe at present but let's see for now.
return(text?.Contains(value) == true);
}
public override object Evaluate(IExpression[] parameters, ExpressiveOptions options)
{
this.ValidateParameterCount(parameters, 2, 2);
var dateObject = parameters[0].Evaluate(this.Variables);
var hoursObject = parameters[1].Evaluate(this.Variables);
if (dateObject == null || hoursObject == null)
{
return(null);
}
if (dateObject.ToString() == "" || hoursObject.ToString() == "")
{
return(null);
}
DateTime date = Convert.ToDateTime(dateObject);
double hours = Convert.ToDouble(hoursObject);
return(date.AddHours(hours));
}
