/// <summary>
/// Initializes the work unit with new work.
/// </summary>
internal void Initialize(Action inAction, IEnumerator inEnumerator, AsyncFlags inFlags, string inName)
{
m_Status = AllCompleteFlag;
m_Name = inName;
m_Action = inAction;
if (m_Action != null)
{
m_Status = (ushort)(m_Status & ~ActionCompleteFlag);
}
m_Enumerator = inEnumerator;
if (m_Enumerator != null)
{
m_Status = (ushort)(m_Status & ~EnumeratorCompleteFlag);
}
AsyncFlags = inFlags;
if (m_Serial == ushort.MaxValue)
{
m_Serial = 1;
}
else
{
++m_Serial;
}
}
internal AsyncWorker(AsyncScheduler inScheduler, AsyncFlags inPriorityFlags)
{
m_Scheduler = inScheduler;
m_BackgroundQueue = new Queue <AsyncWorkUnit>(64);
m_MainThreadOnlyQueue = new Queue <AsyncWorkUnit>(64);
m_PriorityFlags = inPriorityFlags;
}
/// <summary>
/// Executes a set of actions.
/// </summary>
static public AsyncHandle Sequence(IEnumerable <Action> inActions, AsyncFlags inFlags = AsyncFlags.Default)
{
if (inActions == null)
{
return(AsyncHandle.Null);
}
return(Schedule(SequenceImpl(inActions), inFlags));
}
/// <summary>
/// Clears the work unit's contents.
/// </summary>
internal void Clear()
{
m_Status = AllCompleteFlag;
m_Action = null;
DisposeUtils.DisposeObject(ref m_Enumerator);
AsyncFlags = 0;
m_Nested.Clear();
m_OnStop = null;
m_Name = null;
}
/// <summary>
/// Schedules an enumerated procedure to be executed asynchronously.
/// </summary>
static public AsyncHandle Schedule(IEnumerator inEnumerator, AsyncFlags inFlags = AsyncFlags.Default)
{
Manager m = Manager.Get();
if (m != null)
{
m.InitializeAsync();
return(m.Scheduler.Schedule(inEnumerator, inFlags));
}
return(AsyncHandle.Null);
}
// Allocates a work unit for the given enumerator.
private AsyncWorkUnit AllocUnit(IEnumerator inEnumerator, AsyncFlags inFlags)
{
AsyncWorkUnit unit = AllocUnitImpl();
#if DEVELOPMENT
string name = Fiber.GetTypeName(inEnumerator.GetType());
#else
string name = "[not used]";
#endif // DEVELOPMENT
unit.Initialize(null, inEnumerator, inFlags, name);
return(unit);
}
// Allocates a work unit for the given action.
private AsyncWorkUnit AllocUnit(Action inAction, AsyncFlags inFlags)
{
AsyncWorkUnit unit = AllocUnitImpl();
#if DEVELOPMENT
string name = string.Format("{0}->{1}::{2}", inAction.Target, inAction.Method.DeclaringType.FullName, inAction.Method.Name);
#else
string name = "[not used]";
#endif // DEVELOPMENT
unit.Initialize(inAction, null, inFlags, name);
return(unit);
}
// Returns the worker for the given priority.
private AsyncWorker GetWorker(AsyncFlags inPriority)
{
if ((inPriority & AsyncFlags.HighPriority) != 0)
{
return(m_HighPriorityWorker);
}
if ((inPriority & AsyncFlags.LowPriority) != 0)
{
return(m_LowPriorityWorker);
}
return(m_NormalPriorityWorker);
}
/// <summary>
/// Schedules an enumerated action.
/// </summary>
internal AsyncHandle Schedule(IEnumerator inEnumerator, AsyncFlags inFlags)
{
if (inEnumerator == null)
{
return(AsyncHandle.Null);
}
AsyncWorkUnit unit = AllocUnit(inEnumerator, inFlags);
ScheduleImpl(unit);
return(unit.GetHandle());
}
/// <summary>
/// Schedules an action.
/// </summary>
internal AsyncHandle Schedule(Action inAction, AsyncFlags inFlags)
{
if (inAction == null)
{
return(AsyncHandle.Null);
}
AsyncWorkUnit unit = AllocUnit(inAction, inFlags);
ScheduleImpl(unit);
return(unit.GetHandle());
}
/// <summary>
/// Executes an operation on each element in an array, additionally passing in the element index.
/// </summary>
static public AsyncHandle ForEach <T>(T[] inElements, Routine.IndexedElementOperation <T> inOperation, AsyncFlags inFlags = AsyncFlags.Default)
{
if (inElements == null || inElements.Length == 0 || inOperation == null)
{
return(AsyncHandle.Null);
}
return(Schedule(ForEachImpl <T>(inElements, inOperation), inFlags));
}
/// <summary>
/// Executes an operation on each element in a set.
/// </summary>
static public AsyncHandle ForEach <T>(IEnumerable <T> inElements, Routine.ElementOperation <T> inOperation, AsyncFlags inFlags = AsyncFlags.Default)
{
if (inElements == null || inOperation == null)
{
return(AsyncHandle.Null);
}
return(Schedule(ForEachImpl <T>(inElements, inOperation), inFlags));
}
/// <summary>
/// Executes a set of actions.
/// </summary>
static public AsyncHandle Sequence(AsyncFlags inFlags, params Action[] inActions)
{
return(Sequence(inActions, inFlags));
}
/// <summary>
/// Executes a set of operations on the indices between from (inclusive) and to (exclusive).
/// </summary>
static public AsyncHandle For(int inFrom, int inTo, Routine.IndexOperation inOperation, AsyncFlags inFlags = AsyncFlags.Default)
{
if (inOperation == null || inFrom >= inTo)
{
return(AsyncHandle.Null);
}
return(Schedule(ForImpl(inFrom, inTo, inOperation), inFlags));
}
public void Iterate(int inFrom, int inTo, AsyncFlags inFlags)
{
handle.Cancel();
handle = Async.For(inFrom, inTo, LogTimestamp, inFlags);
first = true;
}
