/// <summary>
/// Called by TaskGroup when finishing its tasks, always on main thread
/// </summary>
/// <param name="timePair"></param>
/// <returns></returns>
internal int PopFinalizationCounter(PTTimePair timePair)
{
var count = m_counters[timePair];
m_counters[timePair] = 0;
return(count);
}
public PTTask AddTask(PTTimePair timePair, PTTask task)
{
task.EndTime = timePair;
m_tasks.Add(task);
m_subscriber.Subscribe();
m_controller.SubscribeFinalizer(timePair);
return(task);
}
public Subscriber(Action handler, PTTimePair currentTime, IPTSynchronizer synchronizer)
{
subscribed = false;
m_handler = handler;
m_currentTime = currentTime;
m_synchronizer = synchronizer;
m_synchronizerName = synchronizer.ToString();
}
public void Enqueue(PTTimePair endTime, PTThreadTask task)
{
lock (m_lock)
{
m_queue.Enqueue(endTime, task);
Monitor.Pulse(m_lock);
}
}
public PTTask(PTTimePair endTime, Func <object> initialize, Func <object, object> main, Action <object> finalize, uint period = 1)
{
this.EndTime = endTime;
this.initialize = initialize;
this.main = main;
this.finalize = finalize;
this.period = period;
m_counter = period;
}
public PTTaskGroup(IPTSynchronizer synchronizer, PTTimePair timePair, PTController controller)
{
m_subscriber = new Subscriber(HandleTasks, timePair, synchronizer);
m_timePair = timePair;
m_lock = new object();
m_tasks = new List <PTTask>();
m_tasksToFinish = new Queue <PTThreadTask>();
m_controller = controller;
}
public static PTThreadTask Borrow(PTTimePair endTime, PTTask task)
{
var ttask = s_pool.Borrow();
ttask.initialize = task.initialize;
ttask.main = task.main;
ttask.finalize = task.finalize;
ttask.EndTime = endTime;
return(ttask);
}
public static PTTask Borrow(PTTimePair endTime, Func <object> initialize, Func <object, object> main, Action <object> finalize, uint period = 1)
{
var task = s_pool.Borrow();
task.initialize = initialize;
task.main = main;
task.finalize = finalize;
task.period = period;
task.EndTime = endTime;
task.m_counter = 1;
return(task);
}
internal void UnsubscribeFinalizer(PTTimePair timePair)
{
Tasks[timePair].UnsubscribeFinalizer();
}
public PTTask AddTask(PTTimePair endTime, Func <object, object> main, uint period = 1)
{
return(AddTask(endTime, PTTask.Borrow(endTime, null, main, null, period)));
}
/// <summary>
/// Only ever called from TaskGroup.EndTasks(), threadpool has the lock
/// </summary>
/// <param name="timePair"></param>
public void SetPriority(PTTimePair timePair)
{
m_threadPool.Prioritize(timePair);
}
public static void Unsubscribe(PTTimePair timePair, Action handler)
{
PTAddon.Instance.Synchronizers[timePair.EventTime].Unsubscribe(timePair.UpdateEvent, handler);
}
private PTThreadTask Dequeue(PTTimePair endTime)
{
m_count--;
return(m_tasks[endTime].Dequeue());
}
internal void Enqueue(PTTimePair endTime, PTThreadTask task)
{
m_tasks[endTime].Enqueue(task);
m_count++;
}
public static PTTask AddTask(PTTimePair startTime, PTTimePair endTime, Func <object, object> task, uint period = 1)
{
return(PTAddon.Instance.Controller.Tasks[startTime].AddTask(endTime, task, period));
}
public static string ToName(PTTimePair value)
{
return(s_nameMap[value]);
}
public static PTTask AddTask(PTTimePair startTime, PTTimePair endTime, Func <object> initializer, Func <object, object> task, Action <object> finalizer, uint period = 1)
{
return(PTAddon.Instance.Controller.Tasks[startTime].AddTask(endTime, initializer, task, finalizer, period));
}
public static bool SubscriptionStatus(PTTimePair taskGroup)
{
return(PTAddon.Instance.Controller.Tasks[taskGroup].SubscriptionStatus);
}
public static PTTask AddTask(PTTimePair startTime, PTTimePair endTime, PTTask task)
{
return(PTAddon.Instance.Controller.Tasks[startTime].AddTask(endTime, task));
}
public static bool RemoveTask(PTTimePair startTime, Func <object, object> task)
{
return(PTAddon.Instance.Controller.Tasks[startTime].RemoveTask(task));
}
public void Prioritize(PTTimePair eventTime)
{
m_queue.Priority = eventTime;
}
public PTTask AddTask(PTTimePair endTime, Func <object> initialize, Func <object, object> main, Action <object> finalize, uint period = 1)
{
return(AddTask(endTime, PTTask.Borrow(endTime, initialize, main, finalize, period)));
}
public static void ClearTasks(PTTimePair startTime)
{
PTAddon.Instance.Controller.Tasks[startTime].ClearTasks();
}
