internal async void Execute(TimeSpan dueTime, TimeSpan period, ValueFunc <CancellationToken, Task <bool> > callback)
{
try
{
await System.Threading.Tasks.Task.Delay(dueTime, cancellation.Token).ConfigureAwait(false);
while (await callback.Invoke(cancellation.Token).ConfigureAwait(false))
{
await System.Threading.Tasks.Task.Delay(period, cancellation.Token).ConfigureAwait(false);
}
TrySetResult(true);
}
catch (OperationCanceledException)
{
TrySetResult(false);
}
catch (Exception e)
{
TrySetException(e);
}
finally
{
cancellation.Dispose();
}
}
internal TimerCompletionSource(TimeSpan dueTime, TimeSpan period, ValueFunc <CancellationToken, Task <bool> > callback, CancellationToken token)
{
cancellation = CancellationTokenSource.CreateLinkedTokenSource(token);
this.dueTime = dueTime;
this.period = period;
this.callback = callback;
continuation = Execute;
}
public TimelineFunctionGraphModel(ValueFunc func, EnvelopeFunc minFunc, EnvelopeFunc maxFunc, float begin, float end)
{
this.func = func;
this.minFunc = minFunc;
this.maxFunc = maxFunc;
this.begin = begin;
this.end = end;
}
public TimelineFunctionGraphModel(ValueFunc func, EnvelopeFunc minFunc, EnvelopeFunc maxFunc, float begin, float end)
{
this.func = func;
this.minFunc = minFunc;
this.maxFunc = maxFunc;
this.begin = begin;
this.end = end;
}
/// <summary>
/// Initializes a new instance of lazy value.
/// </summary>
/// <param name="valueFactory">The function used to compute actual value.</param>
/// <param name="resettable"><see langword="true"/> if previously computed value can be removed and computation executed again when it will be requested; <see langword="false"/> if value can be computed exactly once.</param>
/// <exception cref="ArgumentException"><paramref name="valueFactory"/> doesn't refer to any method.</exception>
public AsyncLazy(ValueFunc <Task <T> > valueFactory, bool resettable = false)
{
if (valueFactory.IsEmpty)
{
throw new ArgumentException(ExceptionMessages.EmptyValueDelegate, nameof(valueFactory));
}
this.resettable = resettable;
factory = valueFactory;
}
GroupBy <T, TKey, TKeySelector>(
this NativeArray <T> source,
ValueFunc <T, TKey> .Struct <TKeySelector> keySelector
)
where T : struct
where TKey : unmanaged, IEquatable <TKey>
where TKeySelector : struct, IFunc <T, TKey>
{
return(source.ToValueSequence().GroupBy(keySelector));
}
void Start()
{
var output = new NativeArray <long>(source.Length, Allocator.Persistent);
var job = new SelectJob <AddOne> {
Source = source, Selector = ValueFunc <int, long> .New <AddOne>(), Output = output
};
job.Run();
Debug.Log($"output: ({string.Join(",", output)})");
output.Dispose();
}
public SequenceToNativeHashMapJob(
ValueSequence <T, TSource, TSourceEnumerator> source,
ValueFunc <T, TKey> .Struct <TKeySelector> keySelector,
ValueFunc <T, TElement> .Struct <TElementSelector> elementSelector,
ref NativeHashMap <TKey, TElement> output
)
{
this.source = source;
this.keySelector = keySelector;
this.elementSelector = elementSelector;
this.output = output;
}
public ArrayToNativeHashMapJob(
NativeArray <T> source,
ValueFunc <T, TKey> .Struct <TKeySelector> keySelector,
ValueFunc <T, TElement> .Struct <TElementSelector> elementSelector,
ref NativeHashMap <TKey, TElement> output
)
{
this.source = source;
this.keySelector = keySelector;
this.elementSelector = elementSelector;
this.output = output;
}
GroupBy <T, TSource, TSourceEnumerator, TKey, TKeySelector>(
this ValueSequence <T, TSource, TSourceEnumerator> source,
ValueFunc <T, TKey> .Struct <TKeySelector> keySelector
)
where T : struct
where TSource : struct, ISequence <T, TSourceEnumerator>
where TSourceEnumerator : struct, IEnumerator <T>
where TKey : unmanaged, IEquatable <TKey>
where TKeySelector : struct, IFunc <T, TKey>
{
var elementSelector = UtilFunctions.SameSelector <T>();
var resultSelector = UtilFunctions.GroupSelector <TKey, T>();
return(source.GroupBy(keySelector, elementSelector, resultSelector));
}
public object GetValue()
{
if (Value != null)
{
return(Value);
}
Func <DataTable <TItem>, object> func = ValueFunc.Compile();
if (func == null)
{
return(string.Empty);
}
return(func.Invoke(DataTable));
}
public static void OrderedInsertion()
{
var comparer = new ValueFunc <long, long, int>(Compare);
var list = new List <long> {
2L
};
list.InsertOrdered(1L, comparer);
Equal(1L, list[0]);
Equal(2L, list[1]);
list = new List <long> {
1L
};
list.InsertOrdered(3L, comparer);
Equal(1L, list[0]);
Equal(3L, list[1]);
list = new List <long> {
1L, 3L, 7L
};
Equal(2L, list.InsertOrdered(4L, comparer));
list.RemoveRange(0, 0);
}
public IgnoreIndex(ValueFunc <T, TResult> .Struct <TSelector> selector)
{
this.selector = selector;
}
private T RemoveFactory(Task <T> task)
{
factory = default; //cleanup factory because it may have captured variables and other objects
return(task.Result);
}
/// <summary> /// Applies the specified asynchronous action to each collection element. /// </summary> /// <typeparam name="T">Type of elements in the collection.</typeparam> /// <param name="collection">A collection to enumerate. Cannot be <see langword="null"/>.</param> /// <param name="action">An action to applied for each element.</param> /// <param name="token">The token that can be used to cancel the enumeration.</param> /// <returns>The task representing asynchronous execution of this method.</returns> /// <exception cref="OperationCanceledException">The enumeration has been canceled.</exception> public static ValueTask ForEachAsync <T>(IEnumerable <T> collection, ValueFunc <T, CancellationToken, ValueTask> action, CancellationToken token = default) => NewSequence.ForEachAsync(collection, action, token);
/// <summary>
/// Returns the first element in a sequence that satisfies a specified condition.
/// </summary>
/// <typeparam name="T">The type of the elements of source.</typeparam>
/// <param name="seq">A collection to return an element from.</param>
/// <param name="filter">A function to test each element for a condition.</param>
/// <param name="token">The token that can be used to cancel enumeration.</param>
/// <returns>The first element in the sequence that matches to the specified filter; or empty value.</returns>
/// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
public static ValueTask <Optional <T> > FirstOrEmptyAsync <T>(IAsyncEnumerable <T> seq, ValueFunc <T, bool> filter, CancellationToken token = default)
where T : notnull
=> NewSequence.FirstOrEmptyAsync(seq, filter, token);
/// <summary>
/// Applies specified action to each collection element asynchronously.
/// </summary>
/// <typeparam name="T">Type of elements in the collection.</typeparam>
/// <param name="collection">A collection to enumerate. Cannot be <see langword="null"/>.</param>
/// <param name="action">An action to applied for each element.</param>
/// <param name="token">The token that can be used to cancel the enumeration.</param>
/// <returns>The task representing asynchronous execution of this method.</returns>
/// <exception cref="OperationCanceledException">The enumeration has been canceled.</exception>
public static async ValueTask ForEachAsync <T>(this IAsyncEnumerable <T> collection, ValueFunc <T, CancellationToken, ValueTask> action, CancellationToken token = default)
{
await foreach (var item in collection.WithCancellation(token))
{
await action.Invoke(item, token).ConfigureAwait(false);
}
}
/// <summary>
/// Returns the first element in a sequence that satisfies a specified condition.
/// </summary>
/// <typeparam name="T">The type of the elements of source.</typeparam>
/// <param name="seq">A collection to return an element from.</param>
/// <param name="filter">A function to test each element for a condition.</param>
/// <param name="token">The token that can be used to cancel enumeration.</param>
/// <returns>The first element in the sequence that matches to the specified filter; or empty value.</returns>
/// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
public static async ValueTask <Optional <T> > FirstOrEmptyAsync <T>(this IAsyncEnumerable <T> seq, ValueFunc <T, bool> filter, CancellationToken token = default)
where T : notnull
{
await foreach (var item in seq.WithCancellation(token))
{
if (filter.Invoke(item))
{
return(item);
}
}
return(Optional <T> .None);
}
public static ValueFunc <T, T> .Struct <Functions.SelectSelf <T> > SelectSelf <T>() where T : struct => ValueFunc <T, T> .New <Functions.SelectSelf <T> >();
internal TWrapper WrapBuffer <TWrapper>(ValueFunc <T[], int, TWrapper> factory) => factory.Invoke(buffer, position);
