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 static CompositeFilterDescriptor CreateDescriptor(
CompositeFilterDescriptor.DescriptorType type,
string propertyName,
params object[] values)
{
if (type == CompositeFilterDescriptor.DescriptorType.Unknown)
{
throw new InvalidOperationException("You cannot create undefined composite filter descriptor.");
}
CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor();
filterDescriptor.PropertyName = propertyName;
switch (type - 1)
{
case CompositeFilterDescriptor.DescriptorType.Unknown:
case CompositeFilterDescriptor.DescriptorType.Between:
if (values != null && values.Length != 2)
{
throw new ArgumentException(nameof(values));
}
if (values == null)
{
values = new object[2];
}
filterDescriptor.LogicalOperator = FilterLogicalOperator.And;
filterDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0]));
filterDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1]));
filterDescriptor.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween;
break;
}
return(filterDescriptor);
}
public static string GetCompositeExpression(
CompositeFilterDescriptor filterDescriptor,
Function <FilterDescriptor, object> formatValue)
{
StringBuilder stringBuilder = new StringBuilder();
for (int index = 0; index < filterDescriptor.filters.Count; ++index)
{
FilterDescriptor filter = filterDescriptor.filters[index];
CompositeFilterDescriptor filterDescriptor1 = filter as CompositeFilterDescriptor;
if (filterDescriptor1 != null || !string.IsNullOrEmpty(filter.PropertyName))
{
string str1 = filterDescriptor1 != null?CompositeFilterDescriptor.GetCompositeExpression(filterDescriptor1, formatValue) : FilterDescriptor.GetExpression(filter, formatValue);
stringBuilder.Append(string.Format("{0}", (object)str1));
string str2 = filterDescriptor.filters.LogicalOperator == FilterLogicalOperator.And ? "AND" : "OR";
if (index < filterDescriptor.filters.Count - 1)
{
stringBuilder.Append(string.Format(" {0} ", (object)str2));
}
}
}
if (stringBuilder.Length > 0)
{
stringBuilder.Insert(0, filterDescriptor.NotOperator ? "NOT (" : "(");
stringBuilder.Append(")");
}
return(stringBuilder.ToString());
}
public static CompositeFilterDescriptor.DescriptorType GetDescriptorType(
CompositeFilterDescriptor compositeDescriptor)
{
CompositeFilterDescriptor.DescriptorType descriptorType = CompositeFilterDescriptor.DescriptorType.Unknown;
if (compositeDescriptor == null || compositeDescriptor.FilterDescriptors.Count != 2)
{
return(descriptorType);
}
FilterDescriptor filterDescriptor1 = compositeDescriptor.FilterDescriptors[0];
FilterDescriptor filterDescriptor2 = compositeDescriptor.FilterDescriptors[1];
if (filterDescriptor1 is CompositeFilterDescriptor || filterDescriptor2 is CompositeFilterDescriptor)
{
return(descriptorType);
}
if (filterDescriptor1.Operator == FilterOperator.IsGreaterThanOrEqualTo && filterDescriptor2.Operator == FilterOperator.IsLessThanOrEqualTo && compositeDescriptor.LogicalOperator == FilterLogicalOperator.And)
{
descriptorType = CompositeFilterDescriptor.DescriptorType.Between;
}
if (compositeDescriptor.NotOperator && descriptorType == CompositeFilterDescriptor.DescriptorType.Between || descriptorType == CompositeFilterDescriptor.DescriptorType.Unknown && filterDescriptor1.Operator == FilterOperator.IsLessThanOrEqualTo && (filterDescriptor2.Operator == FilterOperator.IsGreaterThanOrEqualTo && !compositeDescriptor.NotOperator) && compositeDescriptor.LogicalOperator == FilterLogicalOperator.Or)
{
descriptorType = CompositeFilterDescriptor.DescriptorType.NotBetween;
}
return(descriptorType);
}
public static CompositeFilterDescriptor CreateDescriptor(
CompositeFilterDescriptor.DescriptorType type,
string propertyName,
Type dataType,
params object[] values)
{
if (type == CompositeFilterDescriptor.DescriptorType.Unknown)
{
throw new InvalidOperationException("You cannot create undefined composite filter descriptor.");
}
CompositeFilterDescriptor filterDescriptor1 = new CompositeFilterDescriptor();
filterDescriptor1.PropertyName = propertyName;
switch (type - 1)
{
case CompositeFilterDescriptor.DescriptorType.Unknown:
case CompositeFilterDescriptor.DescriptorType.Between:
if (values != null && values.Length != 2)
{
throw new ArgumentException(nameof(values));
}
if (values == null)
{
values = new object[2];
}
FilterDescriptor filterDescriptor2;
FilterDescriptor filterDescriptor3;
if ((object)dataType == (object)typeof(DateTime))
{
DateTime?nullable1 = new DateTime?();
DateTime?nullable2 = new DateTime?();
if (values[0] != null)
{
nullable1 = new DateTime?((DateTime)values[0]);
}
if (values[1] != null)
{
nullable2 = new DateTime?((DateTime)values[1]);
}
filterDescriptor2 = (FilterDescriptor) new DateFilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, nullable1);
filterDescriptor3 = (FilterDescriptor) new DateFilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, nullable2);
}
else
{
filterDescriptor2 = new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0]);
filterDescriptor3 = new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1]);
}
filterDescriptor1.LogicalOperator = FilterLogicalOperator.And;
filterDescriptor1.FilterDescriptors.AddRange(new FilterDescriptor[2]
{
filterDescriptor2,
filterDescriptor3
});
filterDescriptor1.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween;
break;
}
return(filterDescriptor1);
}
private void RebuildFilter()
{
this.FilterDescriptors.BeginUpdate();
for (int index = this.FilterDescriptors.Count - 1; index >= 0; --index)
{
FilterDescriptor filterDescriptor = this.FilterDescriptors[index];
filterDescriptor.PropertyChanged -= new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged);
this.FilterDescriptors.Remove(filterDescriptor);
}
this.FilterDescriptors.Clear();
FilterDescriptorCollection filterDescriptors = this.FilterDescriptors;
if (this.predicates.Count > 0)
{
filterDescriptors.LogicalOperator = GridViewHelper.GetLogicalOperator(this.predicates[0].BinaryOperator);
}
List <FilterPredicate> validPredicates = this.GetValidPredicates();
for (int index = 0; index < validPredicates.Count; ++index)
{
object[] predicateValues = this.GetPredicateValues(validPredicates[index]);
FilterOperator filterOperator = GridViewHelper.GetFilterOperator(validPredicates[index].Function);
if (filterOperator != FilterOperator.None)
{
FilterDescriptor filterDescriptor = new FilterDescriptor(this.PropertyName, filterOperator, predicateValues[0]);
filterDescriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged);
filterDescriptors.Add(filterDescriptor);
}
else
{
CompositeFilterDescriptor.DescriptorType type = CompositeFilterDescriptor.DescriptorType.Between;
if (this.predicates[index].Function == GridKnownFunction.NotBetween)
{
type = CompositeFilterDescriptor.DescriptorType.NotBetween;
}
CompositeFilterDescriptor descriptor = CompositeFilterDescriptor.CreateDescriptor(type, this.PropertyName, predicateValues[0], predicateValues[1]);
descriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged);
filterDescriptors.Add((FilterDescriptor)descriptor);
}
if (this.IsComposite(validPredicates.Count - index, validPredicates))
{
CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor();
filterDescriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged);
filterDescriptor.LogicalOperator = GridViewHelper.GetLogicalOperator(validPredicates[index + 2].BinaryOperator);
filterDescriptors.Add((FilterDescriptor)filterDescriptor);
filterDescriptors = filterDescriptor.FilterDescriptors;
}
}
this.FilterDescriptors.EndUpdate();
}
public override object Clone()
{
CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor();
filterDescriptor.PropertyName = this.PropertyName;
filterDescriptor.Operator = this.Operator;
filterDescriptor.Value = this.Value;
filterDescriptor.IsFilterEditor = this.IsFilterEditor;
filterDescriptor.notOperator = this.notOperator;
filterDescriptor.LogicalOperator = this.LogicalOperator;
foreach (FilterDescriptor filter in (Collection <FilterDescriptor>) this.filters)
{
filterDescriptor.FilterDescriptors.Add(filter.Clone() as FilterDescriptor);
}
return((object)filterDescriptor);
}
/// <summary>
/// Removes the specified property name.
/// </summary>
/// <param name="propertyName">Name of the property.</param>
/// <param name="predicate">The predicate which determine weather the filter can be deleted.</param>
/// <returns></returns>
public bool Remove(string propertyName, Predicate <FilterDescriptor> predicate)
{
bool result = false;
int index = 0;
this.BeginUpdate();
while (index < this.Count)
{
CompositeFilterDescriptor compositeFilter = this[index] as CompositeFilterDescriptor;
if (compositeFilter != null)
{
if (compositeFilter.FilterDescriptors.Remove(propertyName, predicate))
{
result = true;
}
if (compositeFilter.FilterDescriptors.Count == 0)
{
this.RemoveAt(index);
continue;
}
}
index++;
}
bool notify = result;
index = this.IndexOf(propertyName);
bool performRemove = index >= 0;
if (predicate != null && performRemove)
{
performRemove = predicate(this[index]);
}
if (performRemove)
{
this.RemoveAt(index);
result = true;
}
this.EndUpdate(notify || result);
return(result);
}
private static CompositeFilterDescriptor ConvertDescriptor(
CompositeFilterDescriptor compositeFilter,
CompositeFilterDescriptor.DescriptorType type,
Type dataType)
{
if (compositeFilter == null)
{
throw new ArgumentNullException(nameof(compositeFilter));
}
if (type == CompositeFilterDescriptor.DescriptorType.Unknown)
{
throw new InvalidOperationException("You cannot convert the filter descriptor to unknown type.");
}
CompositeFilterDescriptor filterDescriptor1 = compositeFilter.Clone() as CompositeFilterDescriptor;
while (filterDescriptor1.FilterDescriptors.Count > 2)
{
int index = filterDescriptor1.FilterDescriptors.Count - 1;
filterDescriptor1.FilterDescriptors.RemoveAt(index);
}
while (filterDescriptor1.FilterDescriptors.Count < 2)
{
if ((object)dataType == (object)typeof(DateTime))
{
filterDescriptor1.FilterDescriptors.Add((FilterDescriptor) new DateFilterDescriptor());
}
else
{
filterDescriptor1.FilterDescriptors.Add(new FilterDescriptor());
}
}
if (type == CompositeFilterDescriptor.DescriptorType.Between || type == CompositeFilterDescriptor.DescriptorType.NotBetween)
{
filterDescriptor1.LogicalOperator = FilterLogicalOperator.And;
FilterDescriptor filterDescriptor2 = filterDescriptor1.FilterDescriptors[0];
filterDescriptor2.PropertyName = filterDescriptor1.PropertyName;
filterDescriptor2.Operator = FilterOperator.IsGreaterThanOrEqualTo;
FilterDescriptor filterDescriptor3 = filterDescriptor1.FilterDescriptors[1];
filterDescriptor3.PropertyName = filterDescriptor1.PropertyName;
filterDescriptor3.Operator = FilterOperator.IsLessThanOrEqualTo;
filterDescriptor1.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween;
}
return(filterDescriptor1);
}
private static CompositeFilterDescriptor ConvertDescriptor(CompositeFilterDescriptor compositeFilter, DescriptorType type)
{
if (compositeFilter == null)
{
throw new ArgumentNullException("compositeFilter");
}
if (type == DescriptorType.Unknown)
{
throw new InvalidOperationException("You cannot convert the filter descriptor to unknown type.");
}
CompositeFilterDescriptor result = compositeFilter.Clone() as CompositeFilterDescriptor;
while (result.FilterDescriptors.Count > 2)
{
int lastIndex = result.FilterDescriptors.Count - 1;
result.FilterDescriptors.RemoveAt(lastIndex);
}
while (result.FilterDescriptors.Count < 2)
{
result.FilterDescriptors.Add(new FilterDescriptor());
}
if (type == DescriptorType.Between || type == DescriptorType.NotBetween)
{
result.LogicalOperator = FilterLogicalOperator.And;
FilterDescriptor firstFilterDescriptor = result.FilterDescriptors[0];
firstFilterDescriptor.PropertyName = result.PropertyName;
firstFilterDescriptor.Operator = FilterOperator.IsGreaterThanOrEqualTo;
FilterDescriptor secondFilterDescriptor = result.FilterDescriptors[1];
secondFilterDescriptor.PropertyName = result.PropertyName;
secondFilterDescriptor.Operator = FilterOperator.IsLessThanOrEqualTo;
result.NotOperator = type == DescriptorType.NotBetween;
}
return(result);
}
/// <summary>
/// Creates the descriptor.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="propertyName"></param>
/// <param name="values"></param>
/// <returns></returns>
public static CompositeFilterDescriptor CreateDescriptor(DescriptorType type, string propertyName, params object[] values)
{
if (type == DescriptorType.Unknown)
{
throw new InvalidOperationException("You cannot create undefined composite filter descriptor.");
}
//if (String.IsNullOrEmpty(propertyName))
//{
// throw new ArgumentNullException("propertyName");
//}
CompositeFilterDescriptor compositeDescriptor = new CompositeFilterDescriptor();
compositeDescriptor.PropertyName = propertyName;
switch (type)
{
case DescriptorType.NotBetween:
case DescriptorType.Between:
if (values != null && values.Length != 2)
{
throw new ArgumentException("values");
}
if (values == null)
{
values = new object[2];
}
compositeDescriptor.LogicalOperator = FilterLogicalOperator.And;
compositeDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0]));
compositeDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1]));
compositeDescriptor.NotOperator = type == DescriptorType.NotBetween;
break;
}
return(compositeDescriptor);
}
public bool Remove(string propertyName, Predicate <FilterDescriptor> predicate)
{
bool flag1 = false;
int index1 = 0;
this.BeginUpdate();
while (index1 < this.Count)
{
CompositeFilterDescriptor filterDescriptor = this[index1] as CompositeFilterDescriptor;
if (filterDescriptor != null)
{
if (filterDescriptor.FilterDescriptors.Remove(propertyName, predicate))
{
flag1 = true;
}
if (filterDescriptor.FilterDescriptors.Count == 0)
{
this.RemoveAt(index1);
continue;
}
}
++index1;
}
bool flag2 = flag1;
int index2 = this.IndexOf(propertyName);
bool flag3 = index2 >= 0;
if (predicate != null && flag3)
{
flag3 = predicate(this[index2]);
}
if (flag3)
{
this.RemoveAt(index2);
flag1 = true;
}
this.EndUpdate(flag2 || flag1);
return(flag1);
}
/// <summary>
/// Gets the type of the <see cref="CompositeFilterDescriptor"/>.
/// </summary>
/// <param name="compositeDescriptor">The filter descriptor.</param>
/// <returns></returns>
public static DescriptorType GetDescriptorType(CompositeFilterDescriptor compositeDescriptor)
{
DescriptorType type = DescriptorType.Unknown;
if (compositeDescriptor == null || compositeDescriptor.FilterDescriptors.Count != 2)
{
return(type);
}
FilterDescriptor firstDescriptor = compositeDescriptor.FilterDescriptors[0];
FilterDescriptor secondDescriptor = compositeDescriptor.FilterDescriptors[1];
if (firstDescriptor is CompositeFilterDescriptor || secondDescriptor is CompositeFilterDescriptor)
{
return(type);
}
// Between Descriptor
if (firstDescriptor.Operator == FilterOperator.IsGreaterThanOrEqualTo &&
secondDescriptor.Operator == FilterOperator.IsLessThanOrEqualTo &&
compositeDescriptor.LogicalOperator == FilterLogicalOperator.And)
{
type = DescriptorType.Between;
}
// NotBetween Descriptor
if ((compositeDescriptor.NotOperator && type == DescriptorType.Between) ||
(type == DescriptorType.Unknown && firstDescriptor.Operator == FilterOperator.IsLessThanOrEqualTo &&
secondDescriptor.Operator == FilterOperator.IsGreaterThanOrEqualTo && !compositeDescriptor.NotOperator &&
compositeDescriptor.LogicalOperator == FilterLogicalOperator.Or))
{
type = DescriptorType.NotBetween;
}
return(type);
}
//private void Parse(string expression)
//{
// ExpressionNode root = ExpressionParser.Parse(expression, false);
// //validate name nodes
// this.BeginUpdate();
// this.Clear();
// Stack<ExpressionNode> nodeStack = new Stack<ExpressionNode>();
// nodeStack.Push(root);
// Stack<FilterExpressionCollection> collectionStack = new Stack<FilterExpressionCollection>();
// collectionStack.Push(this);
// while (nodeStack.Count > 0)
// {
// ExpressionNode current = nodeStack.Pop();
// FilterExpressionCollection expressions = collectionStack.Pop();
// UnaryOpNode unaryNode = current as UnaryOpNode;
// if (unaryNode != null)
// {
// if (unaryNode.Op == Operator.Noop)
// {
// nodeStack.Push(((UnaryOpNode)current).Right);
// collectionStack.Push(expressions);
// continue;
// }
// }
// BinaryOpNode binaryNode = current as BinaryOpNode;
// if (binaryNode != null)
// {
// if (this.IsPredicate(binaryNode))
// {
// FilterExpression filterExpression = new FilterExpression();
// expressions.Add(filterExpression);
// continue;
// }
// nodeStack.Push(binaryNode.Right);
// FilterExpressionCollection collection = expressions;
// if(!this.IsPredicate(binaryNode.Right))
// {
// CompositeFilterExpression compositeExpression = new CompositeFilterExpression();
// expressions.Add(compositeExpression);
// collection = compositeExpression.FilterExpressions;
// }
// collectionStack.Push(collection);
// nodeStack.Push(binaryNode.Left);
// collection = expressions;
// if (!this.IsPredicate(binaryNode.Left))
// {
// CompositeFilterExpression compositeExpression = new CompositeFilterExpression();
// compositeExpression.BinaryOperator = (binaryNode.Op == Operator.And) ? FilterExpression.BinaryOperation.AND : FilterExpression.BinaryOperation.OR;
// expressions.Add(compositeExpression);
// collection = compositeExpression.FilterExpressions;
// }
// collectionStack.Push(collection);
// }
// }
// this.EndUpdate();
//}
//private bool IsPredicate(ExpressionNode node)
//{
// while (node is UnaryOpNode)
// {
// node = ((UnaryOpNode)node).Right;
// }
// BinaryOpNode binaryNode = node as BinaryOpNode;
// if (binaryNode == null)
// {
// return false;
// }
// if (binaryNode.Left is NameNode || binaryNode.Right is NameNode)
// {
// return true;
// }
// return false;
//}
private void Parse(string expression)
{
ExpressionNode root = ExpressionParser.Parse(expression, false);
//validate name nodes
this.BeginUpdate();
this.Clear();
Stack <ExpressionNode> nodeStack = new Stack <ExpressionNode>();
nodeStack.Push(root);
Stack <FilterDescriptorCollection> collectionStack = new Stack <FilterDescriptorCollection>();
collectionStack.Push(this);
while (nodeStack.Count > 0)
{
ExpressionNode current = nodeStack.Pop();
FilterDescriptorCollection expressions = collectionStack.Pop();
UnaryOpNode unaryNode = current as UnaryOpNode;
if (unaryNode != null)
{
if (unaryNode.Op == Operator.Noop)
{
nodeStack.Push(((UnaryOpNode)current).Right);
collectionStack.Push(expressions);
continue;
}
}
BinaryOpNode binaryNode = current as BinaryOpNode;
if (binaryNode != null)
{
if (this.IsPredicate(binaryNode))
{
FilterDescriptor filterDescriptor = this.CreateFilterDescriptor(binaryNode);
expressions.Add(filterDescriptor);
continue;
}
nodeStack.Push(binaryNode.Right);
FilterDescriptorCollection collection = expressions;
if (!this.IsPredicate(binaryNode.Right))
{
CompositeFilterDescriptor compositeExpression = new CompositeFilterDescriptor();
expressions.Add(compositeExpression);
collection = compositeExpression.FilterDescriptors;
}
collectionStack.Push(collection);
nodeStack.Push(binaryNode.Left);
collection = expressions;
if (!this.IsPredicate(binaryNode.Left))
{
CompositeFilterDescriptor compositeExpression = new CompositeFilterDescriptor();
compositeExpression.LogicalOperator = (binaryNode.Op == Operator.And) ? FilterLogicalOperator.And : FilterLogicalOperator.Or;
expressions.Add(compositeExpression);
collection = compositeExpression.FilterDescriptors;
}
collectionStack.Push(collection);
}
}
this.EndUpdate();
}
public static string GetCompositeExpression(CompositeFilterDescriptor filterDescriptor)
{
return(CompositeFilterDescriptor.GetCompositeExpression(filterDescriptor, (Function <FilterDescriptor, object>)null));
}
private void Parse(string expression)
{
ExpressionNode binaryNode1 = ExpressionParser.Parse(expression, false);
this.BeginUpdate();
this.Clear();
Stack <ExpressionNode> expressionNodeStack = new Stack <ExpressionNode>();
expressionNodeStack.Push(binaryNode1);
Stack <FilterDescriptorCollection> descriptorCollectionStack = new Stack <FilterDescriptorCollection>();
descriptorCollectionStack.Push(this);
this.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode1);
bool flag = false;
while (expressionNodeStack.Count > 0)
{
ExpressionNode expressionNode = expressionNodeStack.Pop();
FilterDescriptorCollection descriptorCollection1 = descriptorCollectionStack.Pop();
UnaryOpNode unaryOpNode = expressionNode as UnaryOpNode;
if (unaryOpNode != null)
{
if (unaryOpNode.Op == Operator.Noop)
{
expressionNodeStack.Push(((UnaryOpNode)expressionNode).Right);
descriptorCollectionStack.Push(descriptorCollection1);
continue;
}
if (unaryOpNode.Op == Operator.Not)
{
expressionNodeStack.Push(((UnaryOpNode)expressionNode).Right);
flag = true;
descriptorCollectionStack.Push(descriptorCollection1);
continue;
}
}
BinaryOpNode binaryNode2 = expressionNode as BinaryOpNode;
if (binaryNode2 != null)
{
if (this.IsPredicate((ExpressionNode)binaryNode2))
{
FilterDescriptor filterDescriptor = this.CreateFilterDescriptor(binaryNode2);
if (flag)
{
filterDescriptor.Operator = this.GetNegativeOperator(filterDescriptor.Operator);
flag = false;
}
descriptorCollection1.Add(filterDescriptor);
}
else
{
expressionNodeStack.Push(binaryNode2.Right);
FilterDescriptorCollection descriptorCollection2 = descriptorCollection1;
if (!this.IsPredicate(binaryNode2.Right))
{
CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor();
filterDescriptor.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode2.Right);
descriptorCollection1.Add((FilterDescriptor)filterDescriptor);
descriptorCollection2 = filterDescriptor.FilterDescriptors;
}
descriptorCollectionStack.Push(descriptorCollection2);
expressionNodeStack.Push(binaryNode2.Left);
FilterDescriptorCollection descriptorCollection3 = descriptorCollection1;
if (!this.IsPredicate(binaryNode2.Left))
{
CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor();
filterDescriptor.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode2.Left);
descriptorCollection1.Add((FilterDescriptor)filterDescriptor);
descriptorCollection3 = filterDescriptor.FilterDescriptors;
}
descriptorCollectionStack.Push(descriptorCollection3);
}
}
}
this.EndUpdate();
}
public CompositeFilterDescriptor ConvertTo(
CompositeFilterDescriptor.DescriptorType type)
{
return(CompositeFilterDescriptor.ConvertDescriptor(this, type, (Type)null));
}
public CompositeFilterDescriptor ConvertTo(
CompositeFilterDescriptor.DescriptorType type,
Type dataType)
{
return(CompositeFilterDescriptor.ConvertDescriptor(this, type, dataType));
}
