private static Dictionary <Hour, int> __scheduleArrivals(int arrivalsPerMonth, int lengthInHours)
{
Dictionary <Hour, int> schedule = new Dictionary <Hour, int>();
SimulationTimeSpan timespan = new SimulationTimeSpan(new Hour(0), new Hour(lengthInHours - 1));
Hour hour = new Hour(0);
while (hour <= timespan.End)
{
schedule[hour] = arrivalsPerMonth;
hour = hour.FirstHourOfNextMonth();
}
return(schedule);
}
private AllocatedCase _allocateCase(AppealCase appealCase, Hour currentHour)
{
Member chair;
Member rapporteur;
Member other;
chair = _allocateChair();
rapporteur = _allocateRapporteur(chair);
other = _allocateOtherMember(chair, rapporteur);
return(new AllocatedCase(
appealCase,
new CaseBoard(chair, rapporteur, other, _registrar),
currentHour));
}
internal void SetFinish(Hour currentHour)
{
if (Enqueue == null)
{
throw new InvalidOperationException("Cannot set Finish before setting Enqueue.");
}
if (Start == null)
{
throw new InvalidOperationException("Cannot set Finish before setting Start.");
}
if (Finish != null)
{
throw new InvalidOperationException("Finish can only be set once.");
}
Finish = currentHour;
}
internal void Enqueue(Hour currentHour, AllocatedCase ac)
{
switch (ac.Stage)
{
case CaseStage.Summons:
_summonsQueue.Enqueue(currentHour, ac);
break;
case CaseStage.Decision:
_decisionQueue.Enqueue(currentHour, ac);
break;
case CaseStage.OP:
case CaseStage.Finished:
case CaseStage.Undefined:
throw new InvalidOperationException("Appeal is not in Summons or Decision stage.");
}
}
internal void DoWork(Hour currentHour)
{
_incoming.EnqueueForNextStage(currentHour);
_opSchedule.UpdateSchedule(currentHour);
foreach (AllocatedCase startedCase in _opSchedule.StartedCases)
{
startedCase.RecordOPStart(currentHour);
}
foreach (AllocatedCase finishedCase in _opSchedule.FinishedCases)
{
finishedCase.RecordOPFinished(currentHour);
finishedCase.EnqueueForWork(currentHour);
}
_circulation.EnqueueForNextStage(currentHour);
}
internal override BoardReport DoWork(Hour currentHour)
{
BoardReport boardReport = new BoardReport(_members);
_registrar.DoWork(currentHour);
foreach (Member member in _members)
{
//working
AllocatedCase currentCase = _registrar.GetCurrentCase(currentHour, member);
WorkReport report = _memberWork(currentHour, currentCase, member);
boardReport.Add(member, report);
//boardReport.Add(member, _memberWork(currentHour, member));
}
return(boardReport);
}
//working
// used only in
// AllocatedCase.DoWorkAndMakeReport
// RecordFinishedWork (unsed)
internal void RecordFinishedWork(WorkerRole role, Hour currentHour)
{
switch (Stage)
{
case CaseStage.Summons:
SetSummonsFinish(role, currentHour);
break;
case CaseStage.Decision:
SetDecisionFinish(role, currentHour);
break;
case CaseStage.OP:
SetOPFinished(currentHour);
break;
default:
throw new InvalidOperationException("CaseRecord.Recordwork: there is no work to do.");
}
}
//working
// used only in AllocatedCase.EnqueueForWork
internal void RecordEnqueuedForWork(WorkerRole role, Hour currentHour)
{
switch (Stage)
{
case CaseStage.Summons:
SetSummonsEnqueue(role, currentHour);
break;
case CaseStage.Decision:
SetDecisionEnqueue(role, currentHour);
break;
case CaseStage.OP:
SetOPEnqueue(currentHour);
break;
default:
throw new InvalidOperationException("CaseRecord.EnqueueForWork: Case is not in Summons or Decision stage.");
}
}
//working
// used only in
// AllocatedCase.RecordStartOfWork (unused)
// AllocatedCase._setNewWorker (used)
internal void RecordStartOfWork(WorkerRole role, Hour currentHour)
{
switch (Stage)
{
case CaseStage.Summons:
SetSummonsStart(role, currentHour);
break;
case CaseStage.Decision:
SetDecisionStart(role, currentHour);
break;
case CaseStage.OP:
SetOPStart(currentHour);
break;
default:
throw new InvalidOperationException("CaseRecord.RecordStartOfWork: no summons or decision work to start.");
}
}
internal WorkerRole EnqueueForNextWorker(Hour currentHour, AllocatedCase allocatedCase)
{
CaseWorker nextWorker = null;
if (_workerQueues[CaseStage.Summons].Count > 0)
{
nextWorker = _workerQueues[CaseStage.Summons].Dequeue();
}
else if (_workerQueues[CaseStage.Decision].Count > 0)
{
nextWorker = _workerQueues[CaseStage.Decision].Dequeue();
}
if (nextWorker == null)
{
return(WorkerRole.None);
}
_registrar.EnqueueForWorker(currentHour, nextWorker, allocatedCase);
return(nextWorker.Role);
}
internal override void AddToCirculationQueue(AllocatedCase allocatedCase, Hour currentHour)
{
_registrar.AddToCirculation(currentHour, allocatedCase);
}
internal void SetDecisionFinish(WorkerRole role, Hour currentHour) //ok
{
_decisionRecords[role].SetFinish(currentHour);
}
internal abstract bool IsBlocked(Hour hour, Member member);
internal abstract void UpdateSchedule(Hour currentHour);
internal abstract void Schedule(Hour currentHour, AllocatedCase allocatedCase);
internal abstract AllocatedCase GetOPWork(Hour hour, Member member);
internal void SetDecisionStart(WorkerRole role, Hour currentHour) //ok
{
_decisionRecords[role].SetStart(currentHour);
}
internal abstract BoardReport DoWork(Hour currentHour);
internal void Enqueue(Hour hour, AllocatedCase t)
{
_queue.Enqueue(t);
_timeOfEnqueuing[t] = hour;
}
internal void Enqueue(Hour currentHour, AllocatedCase ac, WorkerRole role)
{
_queues[role].Enqueue(currentHour, ac);
}
internal void SetOPFinished(Hour currentHour) //ok
{
OP.SetFinish(currentHour);
}
internal void ScheduleOP(Hour currentHour, AllocatedCase allocatedCase)
{
_registrar.ScheduleOP(currentHour, allocatedCase);
}
internal abstract AllocatedCase ProcessNewCase(AppealCase appealCase, Hour currentHour);
internal BoardReport Read(Hour hour)
{
return(_reports[hour]);
}
internal abstract void AddToCirculationQueue(AllocatedCase allocatedCase, Hour currentHour);
internal void SetDecisionEnqueue(WorkerRole role, Hour currentHour) //ok
{
_decisionRecords[role].SetEnqueue(currentHour);
}
internal void Enqueue(Hour currentHour, AllocatedCase allocatedCase)
{
_queue.Enqueue(currentHour, allocatedCase);
}
internal abstract void Add(Hour hour, AllocatedCase allocatedCase);
internal void EnqueueForMember(Hour currentHour, CaseWorker worker, AllocatedCase allocatedCase)
{
_checkMemberIsRegistered(worker.Member);
_memberQueues[worker.Member].Enqueue(currentHour, allocatedCase, worker.Role);
}
internal abstract bool HasOPWork(Hour hour, Member member);
