/// <summary>
/// Invoke the passed <see cref="IEntryProcessor"/> against the
/// entries specified by the passed cache and entries.
/// </summary>
/// <remarks>
/// The invocation is made thread safe by locking the corresponding
/// keys on the cache. If an attempt to lock all the entries at once
/// fails, they will be processed individually one-by-one.
/// </remarks>
/// <param name="cache">
/// The <see cref="IConcurrentCache"/> that the
/// <b>IEntryProcessor</b> works against.
/// </param>
/// <param name="entries">
/// A collection of <see cref="IInvocableCacheEntry"/> objects to
/// process.
/// </param>
/// <param name="agent">
/// The <b>IEntryProcessor</b> to use to process the specified keys.
/// </param>
/// <returns>
/// An <b>IDictionary</b> containing the results of invoking the
/// <b>IEntryProcessor</b> against each of the specified entry.
/// </returns>
public static IDictionary InvokeAllLocked(IConcurrentCache cache,
ICollection entries, IEntryProcessor agent)
{
ICollection keys = ConverterCollections.GetCollection(entries,
ENTRY_TO_KEY_CONVERTER, NullImplementation.GetConverter());
// try to lock them all at once
var listLocked = LockAll(cache, keys, 0);
if (listLocked == null)
{
// the attempt failed; do it one-by-one
var result = new HashDictionary(entries.Count);
foreach (IInvocableCacheEntry entry in entries)
{
result[entry.Key] = InvokeLocked(cache, entry, agent);
}
return(result);
}
try
{
return(agent.ProcessAll(entries));
}
finally
{
UnlockAll(cache, listLocked);
}
}
/// <summary>
/// Process a set of <see cref="IInvocableCacheEntry"/> objects
/// in order to produce an aggregated result.
/// </summary>
/// <param name="entries">
/// A collection of read-only <b>IInvocableCacheEntry</b>
/// objects to aggregate.
/// </param>
/// <returns>
/// The aggregated result from processing the entries.
/// </returns>
public virtual object Aggregate(ICollection entries)
{
PartialResult resultPartial = new PartialResult(Comparer);
IConverter converter = new ExtractingConverter(Extractor);
AddToResult(ConverterCollections.GetCollection(entries, converter, converter), resultPartial);
return(IsParallel
? (object)resultPartial
: (object)FinalizeResult(resultPartial));
}
public void ConverterCollectionTests()
{
ArrayList list = new ArrayList();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
list.Add(cDown.Convert(1));
list.Add(cDown.Convert(2));
list.Add(cDown.Convert(3));
ICollection convCol = ConverterCollections.GetCollection(list, cUp, cDown);
Assert.IsNotNull(convCol);
Assert.AreEqual(convCol.Count, list.Count);
Assert.AreEqual(convCol.IsSynchronized, list.IsSynchronized);
Assert.AreEqual(convCol.SyncRoot, list.SyncRoot);
object[] a = new object[convCol.Count];
convCol.CopyTo(a, 0);
Assert.AreEqual(a.Length, convCol.Count);
for (int i = 0; i < convCol.Count; i++)
{
Assert.AreEqual(a[i], cUp.Convert(list[i]));
}
foreach (object o in convCol)
{
Assert.IsTrue(list.Contains(cDown.Convert(o)));
}
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCollection), convCol);
ConverterCollections.ConverterCollection cc = convCol as ConverterCollections.ConverterCollection;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.Collection, list);
Assert.AreEqual(cc.ConverterDown, cDown);
Assert.AreEqual(cc.ConverterUp, cUp);
cc.Invalidate();
Assert.IsNull(cc.Collection);
Assert.IsNull(cc.ConverterDown);
Assert.IsNull(cc.ConverterUp);
}
