private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[1].IsInteger() && args[2] is string string2) { var format = (args.Count == 4) ? (string)args[3] : FunctionUtils.DefaultDateTimeFormat; Func <DateTime, DateTime> timeConverter; (timeConverter, error) = FunctionUtils.DateTimeConverter(Convert.ToInt64(args[1], CultureInfo.InvariantCulture), string2); if (error == null) { (value, error) = FunctionUtils.NormalizeToDateTime(args[0], dt => (timeConverter(dt).ToString(format, CultureInfo.InvariantCulture), null)); } } else { error = $"{expression} should contain an ISO format timestamp, a time interval integer, a string unit of time and an optional output format string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; var locale = options.Locale != null ? new CultureInfo(options.Locale) : Thread.CurrentThread.CurrentCulture; var format = FunctionUtils.DefaultDateTimeFormat; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (format, locale, error) = FunctionUtils.DetermineFormatAndLocale(args, format, locale, 5); } if (error == null) { if (args[1].IsInteger() && args[2] is string timeUnit) { (value, error) = EvalAddToTime(args[0], Convert.ToInt64(args[1], CultureInfo.InvariantCulture), timeUnit, format, locale); } else { error = $"{expression} should contain an ISO format timestamp, a time interval integer, a string unit of time, an optional output format string and an optional locale string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; var locale = options.Locale != null ? new CultureInfo(options.Locale) : Thread.CurrentThread.CurrentCulture; var format = FunctionUtils.DefaultDateTimeFormat; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (format, locale, error) = FunctionUtils.DetermineFormatAndLocale(args, format, locale, 4); } if (error == null) { if (args[0].IsInteger() && args[1] is string string1) { Func <DateTime, DateTime> timeConverter; (timeConverter, error) = FunctionUtils.DateTimeConverter(Convert.ToInt64(args[0], CultureInfo.InvariantCulture), string1); if (error == null) { value = timeConverter(DateTime.UtcNow).ToString(format, locale); } } else { error = $"{expression} should contain a time interval integer, a string unit of time, an optional output format string and an optional locale string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object result = -1; var(args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[0] is string || args[0] == null) { if (args[1] is string || args[1] == null) { result = FunctionUtils.ParseStringOrNull(args[0]).IndexOf(FunctionUtils.ParseStringOrNull(args[1])); } else { error = $"Can only look for indexof string in {expression}"; } } else if (FunctionUtils.TryParseList(args[0], out IList list)) { result = FunctionUtils.ResolveListValue(list).IndexOf(args[1]); } else { error = $"{expression} works only on string or list."; } } return(result, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { var found = false; var(args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[0] is string string0 && args[1] is string string1) { found = string0.Contains(string1); } else if (FunctionUtils.TryParseList(args[0], out IList ilist)) { // list to find a value var operands = FunctionUtils.ResolveListValue(ilist); foreach (var item in operands) { if (FunctionUtils.CommonEquals(item, args[1])) { found = true; break; } } } else if (args[1] is string string2) { found = FunctionUtils.TryAccessProperty((object)args[0], string2, out var _); } }
private static (object value, string error) EvalJoin(Expression expression, IMemory state, Options options) { object result = null; var(args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (!FunctionUtils.TryParseList(args[0], out IList list)) { error = $"{expression.Children[0]} evaluates to {args[0]} which is not a list."; } else { if (args.Count == 2) { result = string.Join(args[1].ToString(), list.OfType <object>().Select(x => x.ToString())); } else { if (list.Count < 3) { result = string.Join(args[2].ToString(), list.OfType <object>().Select(x => x.ToString())); } else { var firstPart = string.Join(args[1].ToString(), list.OfType <object>().TakeWhile(o => o != null && o != list.OfType <object>().LastOrDefault())); result = firstPart + args[2] + list.OfType <object>().Last().ToString(); } } } } return(result, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[0].IsInteger() && args[1] is string string1) { var format = (args.Count() == 3) ? (string)args[2] : FunctionUtils.DefaultDateTimeFormat; Func <DateTime, DateTime> timeConverter; (timeConverter, error) = FunctionUtils.DateTimeConverter(Convert.ToInt64(args[0]), string1); if (error == null) { value = timeConverter(DateTime.UtcNow).ToString(format); } } else { error = $"{expression} should contain a time interval integer, a string unit of time and an optional output format string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; var locale = options.Locale != null ? new CultureInfo(options.Locale) : Thread.CurrentThread.CurrentCulture; var format = DefaultFormat; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (format, locale, error) = FunctionUtils.DetermineFormatAndLocale(args, format, locale, 4); } if (error == null) { if (args[1] is string targetTimeZone) { (value, error) = EvalConvertFromUTC(args[0], targetTimeZone, format, locale); } else { error = $"{expression} should contain an ISO format timestamp, a destination time zone string, an optional output format string and an optional locale string."; } } return(value, error); }
private static EvaluateExpressionDelegate Evaluator(Func <IReadOnlyList <object>, bool> function, FunctionUtils.VerifyExpression verify) { return((expression, state, options) => { var result = false; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, new Options(options) { NullSubstitution = null }, verify); if (error == null) { try { result = function(args); } #pragma warning disable CA1031 // Do not catch general exception types (we are capturing the exception and returning it) catch (Exception e) #pragma warning restore CA1031 // Do not catch general exception types { // NOTE: This should not happen in normal execution error = e.Message; } } else { // Swallow errors and treat as false error = null; } return (result, error); }); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { TimexProperty parsed = null; string value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (parsed, error) = FunctionUtils.ParseTimexProperty(args[0]); } // if the parsed TimexProperty has no types, then it cannot be resolved if (error == null && parsed.Types.Count == 0) { error = $"The parsed TimexProperty of {args[0]} in {expression} has no types. It can't be resolved to a string value."; } if (error == null) { var formatedTimex = TimexFormat.Format(parsed); try { var resolvedValues = TimexResolver.Resolve(new string[] { formatedTimex }); value = resolvedValues.Values[0].Value; } catch (ArgumentException err) { error = $"{args[0]} in {expression} is not a valid argument. {err.Message}"; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object dateTimeStart = null; object dateTimeEnd = null; object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (dateTimeStart, error) = FunctionUtils.TicksWithError(args[0]); if (error == null) { (dateTimeEnd, error) = FunctionUtils.TicksWithError(args[1]); } else { error = $"{expression} must have two ISO timestamps."; } } if (error == null) { value = (long)dateTimeStart - (long)dateTimeEnd; } return(value, error); }
private static EvaluateExpressionDelegate Evaluator(Func <IReadOnlyList <object>, bool> function, FunctionUtils.VerifyExpression verify) { return((expression, state, options) => { var result = false; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, new Options(options) { NullSubstitution = null }, verify); if (error == null) { // Ensure args are all of same type bool?isNumber = null; foreach (var arg in args) { var obj = arg; if (isNumber.HasValue) { if (obj != null && obj.IsNumber() != isNumber.Value) { error = $"Arguments must either all be numbers or strings in {expression}"; break; } } else { isNumber = obj.IsNumber(); } } if (error == null) { try { result = function(args); } #pragma warning disable CA1031 // Do not catch general exception types (we are capturing the exception and returning it) catch (Exception e) #pragma warning restore CA1031 // Do not catch general exception types { // NOTE: This should not happen in normal execution error = e.Message; } } } else { // Swallow errors and treat as false error = null; } return (result, error); }); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (value, error) = FunctionUtils.TicksWithError(args[0]); } return(value, error); }
private Templates InjectToExpressionFunction() { var totalTempaltes = new List <Templates> { this }.Union(References); foreach (var curTemplates in totalTempaltes) { var globalFuncs = curTemplates.GetGlobalFunctionTable(curTemplates.Options); foreach (var templateName in globalFuncs) { if (curTemplates.Any(u => u.Name == templateName)) { var prefix = string.IsNullOrWhiteSpace(curTemplates.Namespace) ? string.Empty : curTemplates.Namespace + "."; var newGlobalName = prefix + templateName; Expression.Functions.Add(newGlobalName, new ExpressionEvaluator( newGlobalName, (expression, state, options) => { object result = null; var evaluator = new Evaluator(this, LgOptions); var(args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { var parameters = evaluator.TemplateMap[templateName].Parameters; var newScope = parameters.Zip(args, (k, v) => new { k, v }) .ToDictionary(x => x.k, x => x.v); var scope = new CustomizedMemory(state, new SimpleObjectMemory(newScope)); try { result = evaluator.EvaluateTemplate(templateName, scope); } #pragma warning disable CA1031 // Do not catch general exception types catch (Exception err) #pragma warning restore CA1031 // Do not catch general exception types { error = err.Message; } } return(result, error); }, ReturnType.Object)); } } } return(this); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { var format = (args.Count() == 2) ? (string)args[1] : FunctionUtils.DefaultDateTimeFormat; (value, error) = StartOfHourWithError(args[0], format); } return(value, error); }
private static EvaluateExpressionDelegate Evaluator(Func <DateTime, int, DateTime> function) { return((expression, state, options) => { object value = null; string error = null; IReadOnlyList <object> args; var locale = options.Locale != null ? new CultureInfo(options.Locale) : Thread.CurrentThread.CurrentCulture; var format = FunctionUtils.DefaultDateTimeFormat; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (format, locale, error) = FunctionUtils.DetermineFormatAndLocale(args, format, locale, 4); } if (error == null) { if (args[1].IsInteger()) { (value, error) = FunctionUtils.NormalizeToDateTime(args[0], dt => { var result = dt; var(interval, error) = FunctionUtils.ParseInt32(args[1]); if (error == null) { result = function(dt, interval); } return (result, error); }); if (error == null) { value = Convert.ToDateTime(value, CultureInfo.InvariantCulture).ToString(format, locale); } } else { error = $"{expression} should contain an ISO format timestamp and a time interval integer."; } } return (value, error); }); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { TimexProperty parsed = null; bool? value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (parsed, error) = FunctionUtils.ParseTimexProperty(args[0]); } if (error == null) { value = (parsed.Month != null && parsed.DayOfMonth != null) || parsed.DayOfWeek != null; } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[0] is string uri) { (value, error) = EvalUriQuery(uri); } else { error = $"{expression} should contain a URI string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[0].IsInteger()) { value = Convert.ToDouble(args[0], CultureInfo.InvariantCulture) / TicksPerHour; } else { error = $"{expression} should contain an integer of ticks"; } } return(value, error); }
private static EvaluateExpressionDelegate Evaluator(Func <DateTime, int, DateTime> function) { return((expression, state, options) => { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (args[1].IsInteger()) { var formatString = (args.Count == 3 && args[2] is string string1) ? string1 : FunctionUtils.DefaultDateTimeFormat; (value, error) = FunctionUtils.NormalizeToDateTime(args[0], dt => { var result = dt; var(interval, error) = FunctionUtils.ParseInt32(args[1]); if (error == null) { result = function(dt, interval); } return (result, error); }); if (error == null) { value = Convert.ToDateTime(value, CultureInfo.InvariantCulture).ToString(formatString, CultureInfo.InvariantCulture); } } else { error = $"{expression} should contain an ISO format timestamp and a time interval integer."; } } return (value, error); }); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { var format = (args.Count == 3) ? (string)args[2] : FunctionUtils.DefaultDateTimeFormat; if (args[1] is string targetTimeZone) { (value, error) = EvalConvertFromUTC(args[0], targetTimeZone, format); } else { error = $"{expression} should contain an ISO format timestamp, a destination time zone string and an optional output format string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { var format = (args.Count() == 4) ? (string)args[3] : FunctionUtils.DefaultDateTimeFormat; if (args[1].IsInteger() && args[2] is string timeUnit) { (value, error) = EvalAddToTime(args[0], Convert.ToInt64(args[1]), timeUnit, format); } else { error = $"{expression} should contain an ISO format timestamp, a time interval integer, a string unit of time and an optional output format string."; } } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { object value = null; string error = null; IReadOnlyList <object> args; var locale = options.Locale != null ? new CultureInfo(options.Locale) : Thread.CurrentThread.CurrentCulture; var format = FunctionUtils.DefaultDateTimeFormat; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (format, locale, error) = FunctionUtils.DetermineFormatAndLocale(args, format, locale, 3); } if (error == null) { (value, error) = StartOfHourWithError(args[0], format, locale); } return(value, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { TimexProperty parsed = null; string result = null; string error = null; var(validHour, validMinute, validSecond) = (0, 0, 0); IReadOnlyList <object> args; var formatRegex = new Regex("TXX:[0-5][0-9]:[0-5][0-9]"); var currentUtcTime = DateTime.UtcNow; var convertedDateTime = currentUtcTime; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { if (!formatRegex.IsMatch(args[0] as string)) { error = $"{args[0]} must be a timex string which only contains minutes and seconds, for example: 'TXX:15:28'"; } } if (error == null) { if (args.Count == 2 && args[1] is string timezone) { object convertedTimeZone = null; (convertedTimeZone, error) = FunctionUtils.ConvertTimeZoneFormat(timezone); if (error == null) { convertedDateTime = TimeZoneInfo.ConvertTimeFromUtc(currentUtcTime, (TimeZoneInfo)convertedTimeZone); } } else { convertedDateTime = currentUtcTime.ToLocalTime(); } } if (error == null) { (parsed, error) = FunctionUtils.ParseTimexProperty((args[0] as string).Replace("XX", "00")); } if (error == null) { var(hour, minute, second) = (convertedDateTime.Hour, convertedDateTime.Minute, convertedDateTime.Second); if (parsed.Minute < minute || (parsed.Minute == minute && parsed.Second < second)) { validHour = hour; } else { validHour = hour - 1; } if (validHour < 0) { validHour += 24; } validMinute = parsed.Minute ?? 0; validSecond = parsed.Second ?? 0; result = TimexProperty.FromTime(new Time(validHour, validMinute, validSecond)).TimexValue; } return(result, error); }
private static (object value, string error) Evaluator(Expression expression, IMemory state, Options options) { TimexProperty parsed = null; string result = null; string error = null; var(validYear, validMonth, validDay) = (0, 0, 0); var currentUtcTime = DateTime.UtcNow; var convertedDateTime = currentUtcTime; IReadOnlyList <object> args; (args, error) = FunctionUtils.EvaluateChildren(expression, state, options); if (error == null) { (parsed, error) = FunctionUtils.ParseTimexProperty(args[0]); } if (error == null) { if (parsed.Year != null || parsed.Month == null || parsed.DayOfMonth == null) { error = $"{args[0]} must be a timex string which only contains month and day-of-month, for example: 'XXXX-10-31'."; } } if (error == null) { if (args.Count == 2 && args[1] is string timezone) { object convertedTimeZone = null; (convertedTimeZone, error) = FunctionUtils.ConvertTimeZoneFormat(timezone); if (error == null) { convertedDateTime = TimeZoneInfo.ConvertTimeFromUtc(currentUtcTime, (TimeZoneInfo)convertedTimeZone); } } else { convertedDateTime = currentUtcTime.ToLocalTime(); } } if (error == null) { var(year, month, day) = (convertedDateTime.Year, convertedDateTime.Month, convertedDateTime.Day); if (parsed.Month <= month || (parsed.Month == month && parsed.DayOfMonth < day)) { validYear = year; } else { validYear = year - 1; } validMonth = parsed.Month ?? 0; validDay = parsed.DayOfMonth ?? 0; if (validMonth == 2 && validDay == 29) { while (!DateTime.IsLeapYear(validYear)) { validYear -= 1; } } result = TimexProperty.FromDate(new DateTime(validYear, validMonth, validDay)).TimexValue; } return(result, error); }