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));
}
