/// <summary>
/// Calculates the product of two mutlisets asynchronously with a timeout to restrict long running computations
/// </summary>
/// <param name="multiset">Multiset</param>
/// <param name="other">Other Multiset</param>
/// <param name="timeout">Timeout, if <=0 no timeout is used and product will be computed sychronously</param>
/// <returns></returns>
public static BaseMultiset ProductWithTimeout(this BaseMultiset multiset, BaseMultiset other, long timeout)
{
if (other is IdentityMultiset) return multiset;
if (other is NullMultiset) return other;
if (other.IsEmpty) return new NullMultiset();
if (timeout <= 0)
{
return multiset.Product(other);
}
//Invoke using an Async call
Multiset productSet = new Multiset();
StopToken stop = new StopToken();
GenerateProductDelegate d = new GenerateProductDelegate(GenerateProduct);
IAsyncResult r = d.BeginInvoke(multiset, other, productSet, stop, null, null);
//Wait
int t = (int)Math.Min(timeout, Int32.MaxValue);
r.AsyncWaitHandle.WaitOne(t);
if (!r.IsCompleted)
{
stop.ShouldStop = true;
r.AsyncWaitHandle.WaitOne();
}
return productSet;
}
/// <summary>
/// Calculates the product of two mutlisets asynchronously with a timeout to restrict long running computations
/// </summary>
/// <param name="multiset">Multiset</param>
/// <param name="other">Other Multiset</param>
/// <param name="timeout">Timeout, if <=0 no timeout is used and product will be computed sychronously</param>
/// <returns></returns>
public static BaseMultiset ProductWithTimeout(this BaseMultiset multiset, BaseMultiset other, long timeout)
{
if (other is IdentityMultiset)
{
return(multiset);
}
if (other is NullMultiset)
{
return(other);
}
if (other.IsEmpty)
{
return(new NullMultiset());
}
//If no timeout use default implementation
if (timeout <= 0)
{
return(multiset.Product(other));
}
//Otherwise Invoke using an Async call
BaseMultiset productSet;
#if NET40 && !SILVERLIGHT
if (Options.UsePLinqEvaluation)
{
if (multiset.Count >= other.Count)
{
productSet = new PartitionedMultiset(multiset.Count, other.Count);
}
else
{
productSet = new PartitionedMultiset(other.Count, multiset.Count);
}
}
else
{
#endif
productSet = new Multiset();
#if NET40 && !SILVERLIGHT
}
#endif
StopToken stop = new StopToken();
GenerateProductDelegate d = new GenerateProductDelegate(GenerateProduct);
IAsyncResult r = d.BeginInvoke(multiset, other, productSet, stop, null, null);
//Wait
int t = (int)Math.Min(timeout, Int32.MaxValue);
r.AsyncWaitHandle.WaitOne(t);
if (!r.IsCompleted)
{
stop.ShouldStop = true;
r.AsyncWaitHandle.WaitOne();
}
return(productSet);
}
/// <summary>
/// Calculates the product of two mutlisets asynchronously with a timeout to restrict long running computations
/// </summary>
/// <param name="multiset">Multiset</param>
/// <param name="other">Other Multiset</param>
/// <param name="timeout">Timeout, if <=0 no timeout is used and product will be computed sychronously</param>
/// <returns></returns>
public static BaseMultiset ProductWithTimeout(this BaseMultiset multiset, BaseMultiset other, long timeout)
{
if (other is IdentityMultiset)
{
return(multiset);
}
if (other is NullMultiset)
{
return(other);
}
if (other.IsEmpty)
{
return(new NullMultiset());
}
if (timeout <= 0)
{
return(multiset.Product(other));
}
//Invoke using an Async call
Multiset productSet = new Multiset();
StopToken stop = new StopToken();
GenerateProductDelegate d = new GenerateProductDelegate(GenerateProduct);
IAsyncResult r = d.BeginInvoke(multiset, other, productSet, stop, null, null);
//Wait
int t = (int)Math.Min(timeout, Int32.MaxValue);
r.AsyncWaitHandle.WaitOne(t);
if (!r.IsCompleted)
{
stop.ShouldStop = true;
r.AsyncWaitHandle.WaitOne();
}
return(productSet);
}
/// <summary>
/// Calculates the product of two mutlisets asynchronously with a timeout to restrict long running computations.
/// </summary>
/// <param name="multiset">Multiset.</param>
/// <param name="other">Other Multiset.</param>
/// <param name="timeout">Timeout, if <=0 no timeout is used and product will be computed sychronously.</param>
/// <returns></returns>
public static BaseMultiset ProductWithTimeout(this BaseMultiset multiset, BaseMultiset other, long timeout)
{
if (other is IdentityMultiset)
{
return(multiset);
}
if (other is NullMultiset)
{
return(other);
}
if (other.IsEmpty)
{
return(new NullMultiset());
}
// If no timeout use default implementation
if (timeout <= 0)
{
return(multiset.Product(other));
}
// Otherwise Invoke using an Async call
#if NET40
BaseMultiset productSet;
if (Options.UsePLinqEvaluation)
{
if (multiset.Count >= other.Count)
{
productSet = new PartitionedMultiset(multiset.Count, other.Count);
}
else
{
productSet = new PartitionedMultiset(other.Count, multiset.Count);
}
}
else
{
productSet = new Multiset();
}
#else
var productSet = new Multiset();
#endif
var stop = new StopToken();
var t = (int)Math.Min(timeout, int.MaxValue);
#if NET40 || NETSTANDARD1_4 || NETSTANDARD2_0
var productTask = Task.Factory.StartNew(() => GenerateProduct(multiset, other, productSet, stop));
if (!productTask.Wait(t))
{
stop.ShouldStop = true;
productTask.Wait();
}
return(productSet);
#else
GenerateProductDelegate d = new GenerateProductDelegate(GenerateProduct);
IAsyncResult r = d.BeginInvoke(multiset, other, productSet, stop, null, null);
// Wait
r.AsyncWaitHandle.WaitOne(t);
if (!r.IsCompleted)
{
stop.ShouldStop = true;
r.AsyncWaitHandle.WaitOne();
}
return(productSet);
#endif
}
