/// <summary>
/// Evaluate a predicate Expression and determine whether a key range can
/// be found that completely satisfies the expression. If this method returns
/// true then the key range returned by <see cref="GetKeyRange"/> will return
/// only records which match the expression.
/// </summary>
/// <param name="expression">The expression to evaluate.</param>
/// <returns>
/// True if the key range returned by <see cref="GetKeyRange"/> will perfectly
/// match all records found by the expression.
/// </returns>
public static bool KeyRangeIsExact(Expression <Predicate <KeyValuePair <TKey, TValue> > > expression)
{
if (null == expression)
{
throw new ArgumentNullException("expression");
}
return(KeyExpressionEvaluator <TKey> .KeyRangeIsExact(expression.Body, KeyMemberInfo));
}
/// <summary>
/// Optimize a where statement which uses this collection.
/// </summary>
/// <param name="expression">
/// The predicate determining which items should be enumerated.
/// </param>
/// <returns>
/// An enumerator matching only the records matched by the predicate.
/// </returns>
public PersistentDictionaryLinqKeyEnumerable <TKey, TValue> Where(Expression <Predicate <TKey> > expression)
{
if (null == expression)
{
throw new ArgumentNullException("expression");
}
Predicate <TKey> predicate = KeyExpressionEvaluator <TKey> .KeyRangeIsExact(expression) ? x => true : expression.Compile();
return(new PersistentDictionaryLinqKeyEnumerable <TKey, TValue>(
this.Dictionary,
expression,
predicate,
false));
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>
/// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
/// </returns>
public IEnumerator <TKey> GetEnumerator()
{
// Consider: we could get the enumeration of key ranges, sort them and union overlapping ranges.
// Enumerating the data as several different ranges would be more efficient when the expression
// specifies an OR and the ranges are highly disjoint.
KeyRange <TKey> range = KeyExpressionEvaluator <TKey> .GetKeyRange(this.expression);
this.dictionary.TraceWhere(range, this.isReversed);
if (this.isReversed)
{
return(new PersistentDictionaryReverseEnumerator <TKey, TValue, TKey>(
this.dictionary, range, c => c.RetrieveCurrentKey(), this.predicate));
}
return(new PersistentDictionaryEnumerator <TKey, TValue, TKey>(
this.dictionary, range, c => c.RetrieveCurrentKey(), this.predicate));
}
