public static Operation Create <T>(this Operation operation, Future <T> future, TimeSpan timeout)
{
ArgumentAssert.IsNotNull(operation, "operation");
ArgumentAssert.IsNotNull(future, "future");
return(operation.Create((Action <Action>)(doneAction => future.ReactWith(value => doneAction(), e => doneAction())), timeout));
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyedLazyInitializer<TKey, TValue>"/> class.
/// </summary>
/// <param name="valueFactory">The value factory that will produce a new value given a key.</param>
/// <param name="comparer">The equality comparer that will be used to compare keys.</param>
public KeyedLazyInitializer(Func <TKey, TValue> valueFactory, IEqualityComparer <TKey> comparer)
{
ArgumentAssert.IsNotNull(valueFactory, "valueFactory");
_valueFactory = valueFactory;
_comparer = comparer ?? EqualityComparer <TKey> .Default;
}
/// <summary>
/// Converts the <see cref="IEnumerable{T}"/> into a comma-separated string value.
/// Warning - this method does not escape special characters.
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <param name="values">The values.</param>
/// <param name="toString">The function that converts elements into strings.</param>
/// <returns>A comma-separated string value.</returns>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="values"/> is <see langword="null"/>.</para>
/// <para>- or -</para>
/// <para><paramref name="toString"/> is <see langword="null"/>.</para>
/// </exception>
public static string ToCsvString <T>(this IEnumerable <T> values, Func <T, string> toString)
{
ArgumentAssert.IsNotNull(values, "values");
ArgumentAssert.IsNotNull(toString, "toString");
using (var e = values.GetEnumerator())
{
if (!e.MoveNext())
{
return(string.Empty);
}
var value = toString(e.Current);
if (!e.MoveNext())
{
return(value);
}
var builder = new StringBuilder(value);
do
{
builder.Append(',');
builder.Append(toString(e.Current));
}while (e.MoveNext());
return(builder.ToString());
}
}
/// <summary>
/// Iterates through the collection of futures asynchronously by reacting to each one before moving to the next.
/// This operation does not bock unless the supplied iterator pattern blocks.
/// </summary>
/// <param name="futures">The futures.</param>
/// <param name="stopOnFutureErrors"><see langword="true"/> to complete with an exception if a yielded future fails; <see langword="false"/> to continue execution.</param>
/// <returns>A future that completes after sequentially waiting for completion on each one or when it encounters an exception.</returns>
public static Future ExecuteSequentially(this IEnumerable <Future> futures, bool stopOnFutureErrors = true)
{
ArgumentAssert.IsNotNull(futures, "futures");
var iterator = new SequentialFutureIterator(futures, stopOnFutureErrors);
iterator.Begin();
return(iterator.Result);
}
/// <summary>
/// Instructs the future to react with the specified action when the future is canceled.
/// </summary>
/// <param name="future">The future to subscribe to.</param>
/// <param name="onCancel">The on error reaction.</param>
/// <returns>This future.</returns>
public static IFuture OnCancel(this IFuture future, Action onCancel)
{
ArgumentAssert.IsNotNull(future, "future");
ArgumentAssert.IsNotNull(onCancel, "onCancel");
return(future.OnComplete(() => { if (future.Status == FutureStatus.Canceled)
{
onCancel();
}
}));
}
/// <summary>
/// Instructs the future to react with the specified action when the future completes successfully.
/// </summary>
/// <param name="future">The future to subscribe to.</param>
/// <param name="onSuccess">The on success reaction.</param>
/// <returns>This future.</returns>
public static IFuture OnSuccess(this IFuture future, Action onSuccess)
{
ArgumentAssert.IsNotNull(future, "future");
ArgumentAssert.IsNotNull(onSuccess, "onSuccess");
return(future.OnComplete(() => { if (future.Status == FutureStatus.Success)
{
onSuccess();
}
}));
}
/// <summary>
/// Instructs the future to react with the specified error action.
/// </summary>
/// <param name="future">The future to subscribe to.</param>
/// <param name="onError">The on error reaction.</param>
/// <returns>This future.</returns>
public static IFuture OnError(this IFuture future, Action <Exception> onError)
{
ArgumentAssert.IsNotNull(future, "future");
ArgumentAssert.IsNotNull(onError, "onError");
return(future.OnComplete(() => { if (future.Status == FutureStatus.Failure)
{
onError(future.Error);
}
}));
}
/// <summary>
/// Instructs the future to react with the specified action when the future completes successfully.
/// </summary>
/// <param name="future">The future to subscribe to.</param>
/// <param name="onSuccess">The on success reaction.</param>
/// <returns>This future.</returns>
public static IFuture <T> OnSuccess <T>(this IFuture <T> future, Action <T> onSuccess)
{
ArgumentAssert.IsNotNull(future, "future");
ArgumentAssert.IsNotNull(onSuccess, "onSuccess");
future.OnComplete(() => { if (future.Status == FutureStatus.Success)
{
onSuccess(future.Result);
}
});
return(future);
}
/// <summary>
/// Converts the specified bytes into a hexadecimal string value.
/// </summary>
/// <param name="bytes">The bytes to convert.</param>
/// <returns>The hexadecimal representation of <paramref name="bytes"/>.</returns>
public static string ToHex(this IEnumerable <byte> bytes)
{
ArgumentAssert.IsNotNull(bytes, "bytes");
StringBuilder sb = new StringBuilder();
foreach (var b in bytes)
{
sb.Append(GetHexNibble(b >> 4));
sb.Append(GetHexNibble(b & 0xF));
}
return(sb.ToString());
}
public static void ForwardTo <T>(this Future <T> source, Future <T> destination)
{
ArgumentAssert.IsNotNull(source, "source");
ArgumentAssert.IsNotNull(destination, "destination");
if (source.IsComplete)
{
source.CopyTo(destination);
return;
}
source.OnComplete(() => source.CopyTo(destination));
}
/// <summary>
/// Reads the specified xml attribute as if it were a Boolean string.
/// Returns <paramref name="defaultValue"/> the value was not present or could not be parsed.
/// </summary>
/// <param name="reader">The reader to read from.</param>
/// <param name="attributeName">The name of the attribute.</param>
/// <param name="defaultValue">The value to return in the event that the attribute is missing or invalid.</param>
/// <returns></returns>
public static bool ReadBooleanAttributeOrDefault(this XmlReader reader, string attributeName, bool defaultValue = false)
{
ArgumentAssert.IsNotNull(reader, "reader");
ArgumentAssert.IsNotNullOrEmpty(attributeName, "attributeName");
var val = reader.GetAttribute(attributeName);
bool result;
if (!string.IsNullOrEmpty(val) && bool.TryParse(val, out result))
{
return(result);
}
return(defaultValue);
}
public void ReactWith(IFutureReaction reaction)
{
ArgumentAssert.IsNotNull(reaction, "reaction");
OnComplete(() =>
{
if (HasError)
{
reaction.OnError(Error);
}
else
{
reaction.OnCompleted();
}
});
}