//--------------------------------------- .NET THREADPOOL IMPLEMENTATION --------------------------------------
//--------------------------------------- .NET THREADPOOL IMPLEMENTATION --------------------------------------
//--------------------------------------- MISC --------------------------------------
//--------------------------------------- MISC --------------------------------------
#region MISC
private AutoResetEvent[] GetStartedPackageEvents()
{
List <AutoResetEvent> result = new List <AutoResetEvent>();
for (int i = 0; i < workData.workerPackages.Length; i++)
{
ThreadWorkStatePackage package = workData.workerPackages[i];
if (package.started && !package.finishedWorking)
{
result.Add(package.waitHandle);
}
}
return(result.ToArray());
}
private AutoResetEvent[] GetStartedPackageEvents()
{
List <AutoResetEvent> list = new List <AutoResetEvent>();
int num;
for (int i = 0; i < this.workData.workerPackages.Length; i = num + 1)
{
ThreadWorkStatePackage threadWorkStatePackage = this.workData.workerPackages[i];
bool flag = threadWorkStatePackage.started && !threadWorkStatePackage.finishedWorking;
if (flag)
{
list.Add(threadWorkStatePackage.waitHandle);
}
num = i;
}
return(list.ToArray());
}
public void AbortASyncThreads()
{
bool flag = !this._providerThreadBusy;
if (!flag)
{
this._isAborted = true;
base.StopCoroutine("WaitForCompletion");
bool flag2 = this.workData != null && this.workData.workerPackages != null;
if (flag2)
{
ThreadWorkStatePackage[] workerPackages = this.workData.workerPackages;
Monitor.Enter(workerPackages);
try
{
ThreadWorkStatePackage[] workerPackages2 = this.workData.workerPackages;
for (int i = 0; i < workerPackages2.Length; i++)
{
ThreadWorkStatePackage threadWorkStatePackage = workerPackages2[i];
bool flag3 = threadWorkStatePackage.running && !threadWorkStatePackage.finishedWorking;
if (flag3)
{
threadWorkStatePackage.workerObject.AbortThreadedWork();
}
}
}
finally
{
Monitor.Exit(workerPackages);
}
}
bool flag4 = this.providerThread != null && this.providerThread.IsAlive;
if (flag4)
{
Debug.Log("ThreadPoolScheduler.AbortASyncThreads - Interrupt!");
this.providerThread.Interrupt();
this.providerThread.Join();
}
else
{
Debug.Log("ThreadPoolScheduler.AbortASyncThreads!");
}
this._providerThreadBusy = false;
}
}
private IEnumerator WaitForCompletion()
{
while (true)
{
int num = 0;
if (num != 0)
{
if (num != 1)
{
break;
}
bool isAborted = this._isAborted;
if (isAborted)
{
goto Block_4;
}
int finishedPackagesCount = this.GetFinishedPackagesCount();
bool flag = finishedPackagesCount == this.workData.workerPackages.Length;
if (flag)
{
goto Block_5;
}
int unhandledFinishedPackagesCount = this.GetUnhandledFinishedPackagesCount();
bool debugMode = this.DebugMode;
if (debugMode)
{
Debug.Log(string.Concat(new object[]
{
" ----- unhandledPackages: ",
unhandledFinishedPackagesCount,
" ( out of: ",
finishedPackagesCount,
" completed so far...)"
}));
}
bool flag2 = unhandledFinishedPackagesCount > 0;
if (flag2)
{
ThreadWorkStatePackage[] array = this.workData.workerPackages;
for (int i = 0; i < array.Length; i++)
{
ThreadWorkStatePackage threadWorkStatePackage = array[i];
bool flag3 = threadWorkStatePackage.finishedWorking && !threadWorkStatePackage.eventFired;
if (flag3)
{
bool flag4 = this.onWorkerObjectDoneCallBack != null;
if (flag4)
{
this.onWorkerObjectDoneCallBack(threadWorkStatePackage.workerObject);
}
threadWorkStatePackage.eventFired = true;
}
threadWorkStatePackage = null;
}
array = null;
}
}
else
{
bool debugMode2 = this.DebugMode;
if (debugMode2)
{
num++;
Debug.Log(" ----- WaitForCompletion: " + Thread.CurrentThread.ManagedThreadId);
}
}
if (this._isAborted)
{
goto IL_21E;
}
yield return(new WaitForSeconds(this.WaitForSecondsTime));
}
yield break;
Block_4:
Block_5:
IL_21E:
bool flag5 = !this._isAborted;
if (flag5)
{
bool debugMode3 = this.DebugMode;
if (debugMode3)
{
Debug.Log(" ----- Coroutine knows its done!");
}
IThreadWorkerObject[] finishedObjects = this.GetWorkerObjectsFromPackages();
this.workData.Dispose();
this.workData = null;
this._shedularBusy = false;
bool flag6 = this.onCompleteCallBack != null;
if (flag6)
{
this.onCompleteCallBack(finishedObjects);
}
finishedObjects = null;
}
yield break;
}
