private static bool EvaluateBitMaskFilter(BitMaskFilter bitMaskFilter, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { object obj = null; try { obj = propertyBag[bitMaskFilter.Property]; } catch (PropertyErrorException) { if (shouldThrow) { throw; } return(false); } if (EvaluatableFilter.IsPropertyError(propertyBag, bitMaskFilter.Property, shouldThrow)) { return(false); } if (bitMaskFilter.IsNonZero) { return(0UL != ((ulong)obj & bitMaskFilter.Mask)); } return(0UL == ((ulong)obj & bitMaskFilter.Mask)); }
private static bool EvaluateOrFilter(OrFilter filterOr, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { foreach (QueryFilter filter in filterOr.Filters) { if (EvaluatableFilter.Evaluate(filter, propertyBag, shouldThrow)) { return(true); } } return(false); }
private object[][] FilterUnusedRows(int rowCount) { this.CheckDisposed(null); List <object[]> list = new List <object[]>(rowCount); while (list.Count < rowCount && this.unusedRows.Count > 0) { object[] array = this.unusedRows.Dequeue(); this.aggregationPropertyBag.Bind(array); if (EvaluatableFilter.Evaluate(this.aggregationFilter, this.aggregationPropertyBag)) { if (array.Length > this.columnsRequested) { Array.Resize <object>(ref array, this.columnsRequested); } list.Add(array); } } return(list.ToArray()); }
public virtual void UpdateFilterState(SyncOperation syncOperation) { if (syncOperation.ChangeType == ChangeType.Delete) { this.entriesInFilter.Remove(syncOperation.Id); return; } try { try { bool flag = EvaluatableFilter.Evaluate(this.filter, syncOperation, true); if (flag) { ServerManifestEntry serverManifestEntry = new ServerManifestEntry(syncOperation.Id); serverManifestEntry.UpdateManifestFromPropertyBag(syncOperation); serverManifestEntry.FirstMessageInConversation = syncOperation.FirstMessageInConversation; this.entriesInFilter[syncOperation.Id] = serverManifestEntry; } } catch (PropertyErrorException) { ISyncItem item = syncOperation.GetItem(MailboxSyncProvider.QueryColumns); bool flag = item.IsItemInFilter(this.filter); if (flag) { ServerManifestEntry serverManifestEntry2 = new ServerManifestEntry(syncOperation.Id); serverManifestEntry2.UpdateManifestFromItem(item); this.entriesInFilter[syncOperation.Id] = serverManifestEntry2; } } } catch (ObjectNotFoundException) { } }
private void BuildResultSet(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, QueryFilter optimizationFilter, SortBy[] sortBy, PropertyDefinition[] queryColumns, bool useSortOrder) { MailboxSyncPropertyBag mailboxSyncPropertyBag = new MailboxSyncPropertyBag(queryColumns); ComparisonFilter comparisonFilter = optimizationFilter as ComparisonFilter; mailboxSyncPropertyBag.AddColumnsFromFilter(filter); this.idxSortColumn = mailboxSyncPropertyBag.AddColumn(sortBy[0].ColumnDefinition); SortBy[] sortColumns = null; if (comparisonFilter != null && useSortOrder) { SortOrder sortOrder; switch (comparisonFilter.ComparisonOperator) { case ComparisonOperator.LessThan: case ComparisonOperator.LessThanOrEqual: sortOrder = SortOrder.Descending; break; default: sortOrder = SortOrder.Ascending; break; } sortColumns = new SortBy[] { new SortBy(comparisonFilter.Property, sortOrder) }; } QueryResult queryResult2; QueryResult queryResult = queryResult2 = folder.ItemQuery(itemQueryType, null, sortColumns, mailboxSyncPropertyBag.Columns); try { bool flag = 0 != queryResult.EstimatedRowCount; if (comparisonFilter != null) { flag = queryResult.SeekToCondition(SeekReference.OriginBeginning, comparisonFilter); int currentRow = queryResult.CurrentRow; } if (flag) { int currentRow = queryResult.CurrentRow; int num = -1; if (comparisonFilter != null) { QueryFilter seekFilter = MailboxSyncQueryProcessor.InMemoryFilterQueryResult.CreateNegatedComparisonFilter(comparisonFilter); if (queryResult.SeekToCondition(SeekReference.OriginCurrent, seekFilter)) { num = queryResult.CurrentRow; } queryResult.SeekToOffset(SeekReference.OriginBeginning, currentRow); } this.result = new List <object[]>(queryResult.EstimatedRowCount); do { int num2 = 10000; if (-1 != num) { num2 = num - currentRow; } if (num2 > 10000) { num2 = 10000; } object[][] rows = queryResult.GetRows(num2); if (rows.Length == 0) { break; } for (int i = 0; i < rows.Length; i++) { mailboxSyncPropertyBag.Bind(rows[i]); if (EvaluatableFilter.Evaluate(filter, mailboxSyncPropertyBag)) { this.result.Add(rows[i]); } } }while (-1 == num || queryResult.CurrentRow < num); } } finally { if (queryResult2 != null) { ((IDisposable)queryResult2).Dispose(); } } if (this.result != null) { this.result.Sort(this.GetSortByComparer(sortBy[0])); } }
public bool IsItemInFilter(QueryFilter filter) { this.CheckDisposed("IsItemInFilter"); return(EvaluatableFilter.Evaluate(filter, this.item)); }
private static bool EvaluateComparisonFilter(ComparisonFilter comparisonFilter, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { object obj; try { obj = propertyBag[comparisonFilter.Property]; } catch (PropertyErrorException) { if (shouldThrow) { throw; } return(false); } PropertyError propertyError = obj as PropertyError; if (propertyError != null) { if (shouldThrow) { throw PropertyErrorException.FromPropertyErrorsInternal(new PropertyError[] { propertyError }); } return(false); } else { if (EvaluatableFilter.IsPropertyError(propertyBag, comparisonFilter.Property, shouldThrow)) { return(false); } switch (comparisonFilter.ComparisonOperator) { case ComparisonOperator.Equal: if (comparisonFilter.PropertyValue is Participant) { return(Participant.HasSameEmail(comparisonFilter.PropertyValue as Participant, obj as Participant, false)); } if (obj is MultiValuedProperty <string> && comparisonFilter.PropertyValue is string) { MultiValuedProperty <string> multiValuedProperty = obj as MultiValuedProperty <string>; if (multiValuedProperty.Count == 1) { return(multiValuedProperty[0].Equals(comparisonFilter.PropertyValue)); } } if (obj is SmtpAddress && comparisonFilter.PropertyValue is EmailAddress) { return(obj.Equals((comparisonFilter.PropertyValue as EmailAddress).Address)); } return(obj.Equals(comparisonFilter.PropertyValue)); case ComparisonOperator.NotEqual: return(!obj.Equals(comparisonFilter.PropertyValue)); case ComparisonOperator.LessThan: if (comparisonFilter.PropertyValue is ExDateTime) { return((ExDateTime)obj < (ExDateTime)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is int) { return((int)obj < (int)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is long) { return((long)obj < (long)comparisonFilter.PropertyValue); } throw new InvalidOperationException("Only int, long, and ExDateTime supported for ComparisonFilter <"); case ComparisonOperator.LessThanOrEqual: if (comparisonFilter.PropertyValue is ExDateTime) { return((ExDateTime)obj <= (ExDateTime)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is int) { return((int)obj <= (int)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is long) { return((long)obj <= (long)comparisonFilter.PropertyValue); } throw new InvalidOperationException("Only int, long, and ExDateTime supported for ComparisonFilter <="); case ComparisonOperator.GreaterThan: if (comparisonFilter.PropertyValue is ExDateTime) { return((ExDateTime)obj > (ExDateTime)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is int) { return((int)obj > (int)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is long) { return((long)obj > (long)comparisonFilter.PropertyValue); } throw new InvalidOperationException("Only int, long, and ExDateTime supported for ComparisonFilter >"); case ComparisonOperator.GreaterThanOrEqual: if (comparisonFilter.PropertyValue is ExDateTime) { return((ExDateTime)obj >= (ExDateTime)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is int) { return((int)obj >= (int)comparisonFilter.PropertyValue); } if (comparisonFilter.PropertyValue is long) { return((long)obj >= (long)comparisonFilter.PropertyValue); } throw new InvalidOperationException("Only int, long, and ExDateTime supported for ComparisonFilter >="); default: throw new InvalidOperationException("Unsupported ComparisonOperator: " + ((int)comparisonFilter.ComparisonOperator).ToString()); } } bool result; return(result); }
public static bool Evaluate(QueryFilter filter, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { AndFilter andFilter = filter as AndFilter; if (andFilter != null) { return(EvaluatableFilter.EvaluateAndFilter(andFilter, propertyBag, shouldThrow)); } OrFilter orFilter = filter as OrFilter; if (orFilter != null) { return(EvaluatableFilter.EvaluateOrFilter(orFilter, propertyBag, shouldThrow)); } NotFilter notFilter = filter as NotFilter; if (notFilter != null) { return(!EvaluatableFilter.Evaluate(notFilter.Filter, propertyBag, shouldThrow)); } TextFilter textFilter = filter as TextFilter; if (textFilter != null) { return(EvaluatableFilter.EvaluateTextFilter(textFilter, propertyBag, shouldThrow)); } ComparisonFilter comparisonFilter = filter as ComparisonFilter; if (comparisonFilter != null) { return(EvaluatableFilter.EvaluateComparisonFilter(comparisonFilter, propertyBag, shouldThrow)); } if (filter is TrueFilter) { return(true); } if (filter is FalseFilter) { return(false); } CommentFilter commentFilter = filter as CommentFilter; if (commentFilter != null) { return(EvaluatableFilter.Evaluate(commentFilter.Filter, propertyBag, shouldThrow)); } BitMaskFilter bitMaskFilter = filter as BitMaskFilter; if (bitMaskFilter != null) { return(EvaluatableFilter.EvaluateBitMaskFilter(bitMaskFilter, propertyBag, shouldThrow)); } ExistsFilter existsFilter = filter as ExistsFilter; if (existsFilter != null) { return(EvaluatableFilter.EvaluateExistsFilter(existsFilter, propertyBag)); } PropertyComparisonFilter propertyComparisonFilter = filter as PropertyComparisonFilter; if (propertyComparisonFilter != null) { return(EvaluatableFilter.EvaluatePropertyComparisonFilter(propertyComparisonFilter, propertyBag, shouldThrow)); } throw new NotImplementedException(); }
private static bool EvaluateTextFilter(TextFilter textFilter, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { object obj = null; try { obj = propertyBag[textFilter.Property]; } catch (PropertyErrorException) { if (shouldThrow) { throw; } return(false); } if (EvaluatableFilter.IsPropertyError(propertyBag, textFilter.Property, shouldThrow)) { return(false); } if (obj == null) { return(false); } string text = (string)obj; StringComparison comparisonType; if (textFilter.MatchFlags == MatchFlags.IgnoreCase) { comparisonType = StringComparison.OrdinalIgnoreCase; } else { if (textFilter.MatchFlags != MatchFlags.Default) { throw new NotSupportedException(); } comparisonType = StringComparison.Ordinal; } switch (textFilter.MatchOptions) { case MatchOptions.FullString: return(text.Equals(textFilter.Text, comparisonType)); case MatchOptions.SubString: return(text.IndexOf(textFilter.Text, comparisonType) >= 0); case MatchOptions.Prefix: return(text.StartsWith(textFilter.Text, comparisonType)); case MatchOptions.Suffix: return(text.EndsWith(textFilter.Text, comparisonType)); case MatchOptions.PrefixOnWords: return(text.StartsWith(textFilter.Text, comparisonType) && (text.Length == textFilter.Text.Length || text[textFilter.Text.Length] == '.')); default: throw new NotSupportedException(); } bool result; return(result); }
public static bool Evaluate(QueryFilter filter, IReadOnlyPropertyBag propertyBag) { return(EvaluatableFilter.Evaluate(filter, propertyBag, false)); }