private void FillFilterContext( FilterDescriptor filter, TDataItem item, ExpressionContext context) { CompositeFilterDescriptor filterDescriptor1 = filter as CompositeFilterDescriptor; if (filterDescriptor1 != null) { foreach (FilterDescriptor filterDescriptor2 in (Collection <FilterDescriptor>)filterDescriptor1.FilterDescriptors) { this.FillFilterContext(filterDescriptor2, item, context); } } else { object obj = this.GetFieldValue(item, filter.PropertyName); if (obj is Enum) { obj = (object)Convert.ToInt32(obj); } if (context.ContainsKey(filter.PropertyName)) { context[filter.PropertyName] = obj; } else { context.Add(filter.PropertyName, obj); } } }
public object Evaluate(string expression) { ExpressionNode node = ExpressionParser.Parse(expression, false); if (this.Items.Count == 0 || ExpressionNode.GetNodes <AggregateNode>(node).Count == 0) { return((object)null); } List <NameNode> nodes = ExpressionNode.GetNodes <NameNode>(node); StringCollection stringCollection = new StringCollection(); foreach (NameNode nameNode in nodes) { if (!stringCollection.Contains(nameNode.Name)) { stringCollection.Add(nameNode.Name); } } ExpressionContext context = ExpressionContext.GetContext(Thread.CurrentThread.ManagedThreadId); context.Clear(); for (int index = 0; index < stringCollection.Count; ++index) { if (context.ContainsKey(stringCollection[index])) { context[stringCollection[index]] = this.Items[0][stringCollection[index]]; } else { context.Add(stringCollection[index], this.Items[0][stringCollection[index]]); } } return(node.Eval((object)new AggregateItems <T>((IEnumerable <T>) this.Items), (object)context)); }
protected virtual void Filter(FilterDescriptorCollection descriptors) { FilterDescriptor[] currentDescriptors = descriptors.ToArray(); ExpressionNode node = ExpressionParser.Parse(descriptors.Expression, this.masterTemplate.CaseSensitive); if (this.CurrentOperation != ItemSourceOperation.None || node == null || currentDescriptors.Length == 0) { this.view = this.dataSource; this.CurrentOperation = ItemSourceOperation.None; return; } this.CurrentOperation = ItemSourceOperation.Filtering; List <object> newView = new List <object>(); IList filteredView = this.dataSource; for (int i = 0; i < filteredView.Count; i++) { if (!this.perform) { this.CurrentOperation = ItemSourceOperation.None; return; } object entry = filteredView[i]; ExpressionContext context = new ExpressionContext(); for (int j = 0; j < currentDescriptors.Length; j++) { string member = currentDescriptors[j].PropertyName; if (!context.ContainsKey(member)) { context.Add(member, this.GetValue(entry, member)); } else { context[member] = this.GetValue(entry, member); } } object evalResult = node.Eval(null, context); if (evalResult is bool && (bool)evalResult) { newView.Add(entry); } } this.view = newView; this.CurrentOperation = ItemSourceOperation.None; }
private bool PerformExpressionFilter(TDataItem item) { if (this.filterContext.Count == 0) { return(true); } try { lock (this.syncobjs) { int managedThreadId = Thread.CurrentThread.ManagedThreadId; ExpressionContext expressionContext = managedThreadId != this.mainThreadId ? ExpressionContext.GetContext(managedThreadId) : ExpressionContext.Context; expressionContext.Clear(); expressionContext.CaseSensitive = this.CaseSensitive; for (int index1 = 0; index1 < this.filterContext.Count; ++index1) { string index2 = this.filterContext[index1]; object obj = this.GetFieldValue(item, index2); if (obj is Enum) { obj = (object)Convert.ToInt32(obj); } if (expressionContext.ContainsKey(index2)) { expressionContext[index2] = obj; } else { expressionContext.Add(index2, obj); } } object obj1 = (managedThreadId != this.mainThreadId ? this.GetFilterNode(managedThreadId) : this.filterNode).Eval((object)null, (object)expressionContext); if (obj1 is bool) { return((bool)obj1); } } } catch (Exception ex) { throw new FilterExpressionException("Invalid filter expression.", ex); } return(false); }
/// <summary> /// Evaluates the specified expression. /// </summary> /// <param name="expression">The expression.</param> /// <param name="items">The items.</param> /// <returns></returns> public object Evaluate(string expression, IEnumerable <TDataItem> items) { ExpressionNode node = ExpressionParser.Parse(expression, this.CaseSensitive); List <NameNode> nameNodes = ExpressionNode.GetNodes <NameNode>(node); StringCollection contextProperties = new StringCollection(); foreach (NameNode nameNode in nameNodes) { if (!contextProperties.Contains(nameNode.Name)) { contextProperties.Add(nameNode.Name); } } IEnumerator <TDataItem> e = items.GetEnumerator(); e.MoveNext(); ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int i = 0; i < contextProperties.Count; i++) { if (context.ContainsKey(contextProperties[i])) { context[contextProperties[i]] = e.Current[contextProperties[i]]; } else { context.Add(contextProperties[i], e.Current[contextProperties[i]]); } } if (ExpressionNode.GetNodes <AggregateNode>(node).Count > 0) { return(node.Eval(new AggregateItems <TDataItem>(items), context)); } return(node.Eval(null, context)); }
private bool PerformExpressionFilter(TDataItem item) { if (this.filterContext.Count == 0) { return(false); } try { ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int i = 0; i < this.filterContext.Count; i++) { string fieldName = this.filterContext[i]; if (context.ContainsKey(fieldName)) { context[fieldName] = item[fieldName]; } else { context.Add(fieldName, item[fieldName]); } } object result = this.filterNode.Eval(null, context); if (result is bool) { return((bool)result); } } catch (Exception ex) { throw new FilterExpressionException("Invalid filter expression.", ex); } return(false); }
/// <summary> /// Evaluates the specified expression. /// </summary> /// <param name="expression">The expression.</param> /// <returns></returns> public object Evaluate(string expression) { ExpressionNode node = ExpressionParser.Parse(expression, false); if (this.Items.Count == 0 || ExpressionNode.GetNodes <AggregateNode>(node).Count == 0) { return(null); } List <NameNode> nameNodes = ExpressionNode.GetNodes <NameNode>(node); StringCollection contextProperties = new StringCollection(); foreach (NameNode nameNode in nameNodes) { if (!contextProperties.Contains(nameNode.Name)) { contextProperties.Add(nameNode.Name); } } ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int i = 0; i < contextProperties.Count; i++) { if (context.ContainsKey(contextProperties[i])) { context[contextProperties[i]] = this.Items[0][contextProperties[i]]; } else { context.Add(contextProperties[i], this.Items[0][contextProperties[i]]); } } return(node.Eval(new AggregateItems <T>(this.Items), context)); }
/// <summary> /// Try to evaluate the specified expression. /// </summary> /// <param name="expression">The expression.</param> /// <param name="items">The items.</param> /// <param name="index">Index of item, which the result will be calculated for</param> /// <param name="result">Expression result</param> /// <returns></returns> internal bool TryEvaluate(string expression, IEnumerable <TDataItem> items, int index, out object result) { result = null; ExpressionNode node = null; if (!ExpressionParser.TryParse(expression, this.CaseSensitive, out node)) { return(false); } List <NameNode> nameNodes = ExpressionNode.GetNodes <NameNode>(node); StringCollection contextProperties = new StringCollection(); foreach (NameNode nameNode in nameNodes) { if (!contextProperties.Contains(nameNode.Name)) { contextProperties.Add(nameNode.Name); } } IEnumerator <TDataItem> e = items.GetEnumerator(); while (index >= 0) { if (!e.MoveNext()) { throw new IndexOutOfRangeException(); } index--; } if (e.Current == null) { return(false); } ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int i = 0; i < contextProperties.Count; i++) { if (e.Current.IndexOf(contextProperties[i]) < 0) { return(false); } if (context.ContainsKey(contextProperties[i])) { context[contextProperties[i]] = e.Current[contextProperties[i]]; } else { context.Add(contextProperties[i], e.Current[contextProperties[i]]); } } try { if (ExpressionNode.GetNodes <AggregateNode>(node).Count > 0) { result = node.Eval(new AggregateItems <TDataItem>(items), context); } else { result = node.Eval(null, context); } } catch { return(false); } return(true); }
private object EvaluateExpression(GridViewRowInfo row, GridViewColumn column) { if (row.ViewTemplate.MasterTemplate.Owner.InvokeRequired) { object result = (object)null; row.ViewTemplate.MasterTemplate.Owner.Invoke((Delegate)(() => result = this.EvaluateExpression(row, column))); return(result); } ExpressionNode expressionNode; if (DataUtils.TryParse(column.Expression, row.ViewTemplate.CaseSensitive, out expressionNode)) { ExpressionContext context = ExpressionContext.Context; bool containsAggregate = false; List <GridViewColumn> columnsForExpression = this.GetColumnsForExpression(row.ViewTemplate, expressionNode, out containsAggregate); for (int index1 = 0; index1 < columnsForExpression.Count; ++index1) { if (columnsForExpression[index1] != column) { GridViewColumn index2 = columnsForExpression[index1]; Accessor accessor = index2.Accessor; object obj = !(accessor is ExpressionAccessor) || !row.Cache.ContainsKey((object)index2) ? accessor[row] : row.Cache[index2]; if (context.ContainsKey(index2.Name)) { context[index2.Name] = obj; } else { context.Add(index2.Name, obj); } } } AggregateData aggregateData = (AggregateData)null; if (containsAggregate) { GridViewGroupRowInfo parent = row.Parent as GridViewGroupRowInfo; aggregateData = parent == null ? new AggregateData((IEnumerable <GridViewRowInfo>)row.ViewTemplate.ChildRows) : new AggregateData((IEnumerable <GridViewRowInfo>)parent.ChildRows); } try { object obj1 = expressionNode.Eval((object)aggregateData, (object)context); object obj2 = RadDataConverter.Instance.Parse(column as IDataConversionInfoProvider, obj1); row.Cache[column] = obj2; } catch (InvalidExpressionException ex) { if (!ExpressionAccessor.ExpressionErrorRaised) { string message = string.Format("Invalid Expression: \n\"{0}\"", (object)ex.Message); row.ViewTemplate.SetError(new GridViewCellCancelEventArgs(row, column, (IInputEditor)null), DataUtils.CreateInvalidExpressionException(message)); ExpressionAccessor.ExpressionErrorRaised = true; } } } else if (!ExpressionAccessor.ExpressionErrorRaised) { if (!string.IsNullOrEmpty(column.HeaderText)) { string headerText = column.HeaderText; } else if (!string.IsNullOrEmpty(column.FieldName)) { string fieldName = column.FieldName; } else if (!string.IsNullOrEmpty(column.Name)) { string name = column.Name; } else { string empty = string.Empty; } string message = string.Format("Invalid expression value for [{0}] column!", (object)column.Name); row.ViewTemplate.SetError(new GridViewCellCancelEventArgs(row, column, (IInputEditor)null), DataUtils.CreateInvalidExpressionException(message)); ExpressionAccessor.ExpressionErrorRaised = true; } return(row.Cache[column]); }
public bool TryEvaluate( string expression, IEnumerable <TDataItem> items, int index, out object result) { result = (object)null; ExpressionNode expressionNode = (ExpressionNode)null; if (!ExpressionParser.TryParse(expression, this.CaseSensitive, out expressionNode)) { return(false); } List <NameNode> nodes = ExpressionNode.GetNodes <NameNode>(expressionNode); StringCollection stringCollection = new StringCollection(); foreach (NameNode nameNode in nodes) { if (!stringCollection.Contains(nameNode.Name)) { stringCollection.Add(nameNode.Name); } } IEnumerator <TDataItem> enumerator = items.GetEnumerator(); for (; index >= 0; --index) { if (!enumerator.MoveNext()) { throw new IndexOutOfRangeException(); } } if ((object)enumerator.Current == null) { return(false); } ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int index1 = 0; index1 < stringCollection.Count; ++index1) { if (enumerator.Current.IndexOf(stringCollection[index1]) < 0) { return(false); } if (context.ContainsKey(stringCollection[index1])) { context[stringCollection[index1]] = enumerator.Current[stringCollection[index1]]; } else { context.Add(stringCollection[index1], enumerator.Current[stringCollection[index1]]); } } try { result = ExpressionNode.GetNodes <AggregateNode>(expressionNode).Count <= 0 ? expressionNode.Eval((object)null, (object)context) : expressionNode.Eval((object)new AggregateItems <TDataItem>(items), (object)context); } catch { return(false); } return(true); }
public object Evaluate(string expression, IEnumerable <TDataItem> items) { ExpressionNode node = ExpressionParser.Parse(expression, this.CaseSensitive); List <NameNode> nodes = ExpressionNode.GetNodes <NameNode>(node); StringCollection stringCollection = new StringCollection(); foreach (NameNode nameNode in nodes) { if (!stringCollection.Contains(nameNode.Name)) { stringCollection.Add(nameNode.Name); } } IEnumerator <TDataItem> enumerator = items.GetEnumerator(); enumerator.MoveNext(); ExpressionContext context = ExpressionContext.Context; context.Clear(); for (int index = 0; index < stringCollection.Count; ++index) { if (!RadCollectionView <TDataItem> .isDesignMode.HasValue) { Process currentProcess = Process.GetCurrentProcess(); RadCollectionView <TDataItem> .isDesignMode = new bool?(currentProcess.ProcessName == "devenv"); currentProcess.Dispose(); } if (RadCollectionView <TDataItem> .isDesignMode.HasValue) { if (RadCollectionView <TDataItem> .isDesignMode.Value) { try { if (context.ContainsKey(stringCollection[index])) { context[stringCollection[index]] = enumerator.Current[stringCollection[index]]; continue; } context.Add(stringCollection[index], enumerator.Current[stringCollection[index]]); continue; } catch (Exception ex) { int num = (int)MessageBox.Show(string.Format("Error evaluating expression: {0}", (object)ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Hand); return((object)null); } } } if (context.ContainsKey(stringCollection[index])) { context[stringCollection[index]] = enumerator.Current[stringCollection[index]]; } else { context.Add(stringCollection[index], enumerator.Current[stringCollection[index]]); } } if (ExpressionNode.GetNodes <AggregateNode>(node).Count > 0) { return(node.Eval((object)new AggregateItems <TDataItem>(items), (object)context)); } return(node.Eval((object)null, (object)context)); }