org.javades.jqueues.r5.entity.jq.queue.composite

Class AbstractSimQueueComposite_LocalStart<DJ extends SimJob,DQ extends SimQueue,J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

java.lang.Object

org.javades.jqueues.r5.entity.AbstractSimEntity

org.javades.jqueues.r5.entity.jq.AbstractSimJQ<J,Q>

org.javades.jqueues.r5.entity.jq.queue.AbstractSimQueue<J,Q>

org.javades.jqueues.r5.entity.jq.queue.composite.AbstractSimQueueComposite<DJ,DQ,J,Q>

org.javades.jqueues.r5.entity.jq.queue.composite.AbstractSimQueueComposite_LocalStart<DJ,DQ,J,Q>

Type Parameters:

DJ - The delegate-job type.

DQ - The queue-type for delegate jobs.

J - The job type.

Q - The queue type for jobs.

All Implemented Interfaces:

SimQueueComposite<DJ,DQ,J,Q>, SimQueueSelector<J,DQ>, SimQueue<J,Q>, SimQoS<J,Q>, SimEntity, SimEntityListener, org.javades.jsimulation.r5.SimEventListResetListener

Direct Known Subclasses:

AbstractCollectorSimQueue, AbstractFeedbackSimQueue, AbstractParallelSimQueues, Jackson, Tandem

public abstract class AbstractSimQueueComposite_LocalStart<DJ extends SimJob,DQ extends SimQueue,J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>
extends AbstractSimQueueComposite<DJ,DQ,J,Q>

A partial implementation with LocalStart model of a SimQueueComposite.

This abstract base class implements for a large part composite queues in which the waiting area of the composite queue and its local server-access credits are used to control access to the sub-queues. In other words, arriving jobs may have to wait in the composite waiting area, and upon entering the service area of the local, arrive at the first sub-queue (if applicable).

We call this the LocalStart model for a SimQueueComposite. Many concrete implementations such as Tandem, FB_v and FB_p use this model. In this abstract base class, many methods have been made final in order to ensure compliance with the SimQueue and SimQueueComposite interface. However, the sub-queue event processor processSubQueueNotifications(java.util.List<org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Notification<DJ, DQ>>) can be overridden in order to (carefully) filter or alter sub-queue notifications.

Author:

Jan de Jongh, TNO

Copyright (C) 2005-2017 Jan de Jongh, TNO

This file is covered by the LICENSE file in the root of this project.

Nested Class Summary

Nested classes/interfaces inherited from class org.javades.jqueues.r5.entity.jq.queue.composite.AbstractSimQueueComposite

AbstractSimQueueComposite.RealDelegateJobMapper<J extends SimJob,DJ extends SimJob>

Nested classes/interfaces inherited from class org.javades.jqueues.r5.entity.AbstractSimEntity

AbstractSimEntity.Notifier, AbstractSimEntity.PreNotificationHook

Nested classes/interfaces inherited from interface org.javades.jqueues.r5.entity.jq.queue.SimQueue

SimQueue.AutoRevocationPolicy

Nested classes/interfaces inherited from interface org.javades.jqueues.r5.entity.SimEntity

SimEntity.Action, SimEntity.UnknownNotificationTypePolicy, SimEntity.UnknownOperationPolicy

Field Summary

Fields inherited from class org.javades.jqueues.r5.entity.jq.queue.composite.AbstractSimQueueComposite

realDelegateJobMapper

Fields inherited from class org.javades.jqueues.r5.entity.jq.queue.AbstractSimQueue

eventsScheduled, SANITY

Fields inherited from class org.javades.jqueues.r5.entity.AbstractSimEntity

USE_ARRAY_OPTIMIZATION

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractSimQueueComposite_LocalStart(org.javades.jsimulation.r5.SimEventList eventList, Set<DQ> queues, SimQueueSelector<J,DQ> simQueueSelector, DelegateSimJobFactory delegateSimJobFactory) Creates an abstract network of queues with LocalStart model.

Method Summary

Modifier and Type	Method and Description
Object	getQoS() Returns null since QoS is not supported (by default) with the LocalStart model for composite queues.
Class	getQoSClass() Returns null since QoS is not supported (by default) with the LocalStart model for composite queues.
protected double	getServiceTimeForJob(J job) Calls super method (in order to make implementation final).
protected void	insertJobInQueueUponArrival(J job, double time) Creates the delegate job and administers it.
protected void	insertJobInQueueUponStart(J job, double time) Performs sanity chekcs.
boolean	isStartArmed() Returns true.
protected void	processSubQueueNotifications(List<MultiSimQueueNotificationProcessor.Notification<DJ,DQ>> notifications) Processes the pending atomic notifications from the sub-queues, one at a time (core sub-queue notification processor).
protected void	queueAccessVacationDropSubClass(double time, J job) Calls super method (in order to make implementation final).
protected void	removeJobFromQueueUponDeparture(J departingJob, double time) Departure of the given (real) job.
protected void	removeJobFromQueueUponDrop(J job, double time) Drops the given (real) job.
protected void	removeJobFromQueueUponRevokation(J job, double time, boolean auto) Removes a job upon successful revocation (as determined by our super-class).
protected void	rescheduleAfterArrival(J job, double time) Starts the job if server-access credits are available.
protected void	rescheduleAfterDeparture(J departedJob, double time) Enforces the scheduled revocation on the sub-queue, if applicable.
protected void	rescheduleAfterDrop(J job, double time) Enforces the scheduled revocation on the sub-queue, if applicable.
protected void	rescheduleAfterRevokation(J job, double time, boolean auto) If present, performs the pending revocation on the applicable sub-queue, and check whether that succeeded.
protected void	rescheduleAfterStart(J job, double time) Lets the delegate job arrive at its first queue, or make it depart immediately if no such queue is provided.
protected void	rescheduleForNewServerAccessCredits(double time) Starts waiting jobs (in the local waiting area) as long as there are such jobs and there are (local) server-access credits available.
protected void	resetEntitySubClass() Resets this AbstractSimQueueComposite_LocalStart.
protected void	setServerAccessCreditsSubClass() Takes appropriate action if needed on the server-access credits of sub-queues.

Methods inherited from class org.javades.jqueues.r5.entity.jq.queue.composite.AbstractSimQueueComposite

addRealJobLocal, getCopySimQueues, getCopySubSimQueues, getDelegateJob, getDelegateJobMild, getDelegateSimJobFactory, getIndex, getIndex, getQueue, getQueue, getQueues, getRealJob, getRealJob, getSimQueueSelector, isDelegateJob, isRealJob, notifyResetEntity, notifyStateChanged, notifyUpdate, removeJobsFromQueueLocal, resetSimQueueSelector, selectFirstQueue, selectNextQueue, setDelegateSimJobFactory

Methods inherited from class org.javades.jqueues.r5.entity.jq.queue.AbstractSimQueue

arrive, autoRevoke, cancelDepartureEvent, cancelDepartureEvent, depart, departureFromEventList, drop, getAutoRevocationPolicy, getDepartureEvents, getDepartureEvents, getFirstJob, getFirstJobInServiceArea, getFirstJobInWaitingArea, getJobs, getJobsInServiceArea, getJobsInWaitingArea, getNumberOfJobs, getNumberOfJobsInServiceArea, getNumberOfJobsInWaitingArea, getServerAccessCredits, hasJobs, hasJobsInServiceArea, hasJobsInWaitingArea, hasServerAcccessCredits, isJob, isJobInServiceArea, isJobInWaitingArea, isQueueAccessVacation, registerStdOutSimQueueListener, revoke, revoke, scheduleDepartureEvent, scheduleJobArrival, setAutoRevocationPolicy, setQueueAccessVacation, setServerAccessCredits, start, takeServerAccessCredit, toStringDefault, triggerPotentialNewStartArmed, unregisterStdOutSimQueueListener

Methods inherited from class org.javades.jqueues.r5.entity.AbstractSimEntity

addPendingNotification, addPendingNotification, clearAndUnlockPendingNotificationsIfLocked, delegateOperation, doAfterNotifications, doOperation, fireAndLockPendingNotifications, getEventList, getLastUpdateTime, getRegisteredDelegatedOperations, getRegisteredNotificationTypes, getRegisteredOperations, getSimEntityListeners, getUnknownNotificationTypePolicy, getUnknownOperationPolicy, isIgnoreEventListReset, notifyEventListReset, registerDelegatedOperation, registerNotificationType, registerOperation, registerPreEventHook, registerPreNotificationHook, registerPreUpdateHook, registerSimEntityListener, registerStdOutSimEntityListener, removeDelegationForOperation, resetEntity, setIgnoreEventListReset, setName, setUnknownNotificationTypePolicy, setUnknownOperationPolicy, toString, unregisterSimEntityListener, unregisterStdOutSimEntityListener, update

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.javades.jqueues.r5.entity.jq.queue.SimQueue

arrive, getAutoRevocationPolicy, getCopySimQueue, getJobs, getJobsInServiceArea, getJobsInWaitingArea, getNumberOfJobs, getNumberOfJobsInServiceArea, getNumberOfJobsInWaitingArea, getServerAccessCredits, isJob, isJobInServiceArea, isJobInWaitingArea, isQueueAccessVacation, revoke, revoke, setAutoRevocationPolicy, setQueueAccessVacation, setServerAccessCredits

Methods inherited from interface org.javades.jqueues.r5.entity.SimEntity

doAfterNotifications, doOperation, getEventList, getLastUpdateTime, getRegisteredNotificationTypes, getRegisteredOperations, getSimEntityListeners, getUnknownNotificationTypePolicy, getUnknownOperationPolicy, isIgnoreEventListReset, registerSimEntityListener, resetEntity, setIgnoreEventListReset, setName, setUnknownNotificationTypePolicy, setUnknownOperationPolicy, toStringDefault, unregisterSimEntityListener, update

Methods inherited from interface org.javades.jsimulation.r5.SimEventListResetListener

notifyEventListReset

Constructor Detail

AbstractSimQueueComposite_LocalStart

protected AbstractSimQueueComposite_LocalStart(org.javades.jsimulation.r5.SimEventList eventList,
                                               Set<DQ> queues,
                                               SimQueueSelector<J,DQ> simQueueSelector,
                                               DelegateSimJobFactory delegateSimJobFactory)

Creates an abstract network of queues with LocalStart model.

Parameters:

eventList - The event list to be shared between this queue and the embedded queues.

queues - A set holding the "embedded" queues.

simQueueSelector - The object for routing jobs through the network of embedded queues; if null, no sub-queues will be visited.

delegateSimJobFactory - An optional factory for the delegate SimJobs.

Throws:

IllegalArgumentException - If the event list is null, the queue argument is null, has null members, or contains this composite queue.

See Also:

SimQueueSelector, DelegateSimJobFactory, DefaultDelegateSimJobFactory, resetEntitySubClass()

Method Detail

getQoSClass

public Class getQoSClass()

Returns null since QoS is not supported (by default) with the LocalStart model for composite queues.

Sub-classes are free to override this method and expose a QoS structure as they see fit.

Returns:

null.

getQoS

public Object getQoS()

Returns null since QoS is not supported (by default) with the LocalStart model for composite queues.

Sub-classes are free to override this method and expose a QoS structure as they see fit.

Returns:

null.

resetEntitySubClass

protected void resetEntitySubClass()

Resets this AbstractSimQueueComposite_LocalStart.

Calls super method (not if called from constructor, for which a private variant for local resets is used) and clears the pending revocation event for a sub-queue.

Overrides:

resetEntitySubClass in class AbstractSimQueueComposite<DJ extends SimJob,DQ extends SimQueue,J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

See Also:

removeJobFromQueueUponRevokation(J, double, boolean), rescheduleAfterRevokation(J, double, boolean), SimEntity.resetEntity()

isStartArmed

public final boolean isStartArmed()

Returns true.

Returns:

true.

See Also:

SimQueueListener.notifyNewStartArmed(double, Q, boolean)

queueAccessVacationDropSubClass

protected final void queueAccessVacationDropSubClass(double time,
                                                     J job)

Calls super method (in order to make implementation final).

Overrides:

queueAccessVacationDropSubClass in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

time - The time the job was dropped, i.e., the current time.

job - The dropped job.

See Also:

AbstractSimQueue.arrive(double, J), AbstractSimQueue.setQueueAccessVacation(double, boolean)

insertJobInQueueUponArrival

protected final void insertJobInQueueUponArrival(J job,
                                                 double time)

Creates the delegate job and administers it.

Specified by:

insertJobInQueueUponArrival in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that arrived.

time - The current time (i.e., arrival time of the job).

See Also:

AbstractSimQueue.arrive(double, J), AbstractSimQueueComposite.addRealJobLocal(J), rescheduleAfterArrival(J, double)

rescheduleAfterArrival

protected final void rescheduleAfterArrival(J job,
                                            double time)

Starts the job if server-access credits are available.

Specified by:

rescheduleAfterArrival in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that arrived (and is already present in AbstractSimQueue.getJobs()).

time - The current time (i.e., the arrival time of the job).

See Also:

AbstractSimQueue.arrive(double, J), AbstractSimQueue.hasServerAcccessCredits(), insertJobInQueueUponArrival(J, double)

removeJobFromQueueUponDrop

protected final void removeJobFromQueueUponDrop(J job,
                                                double time)

Drops the given (real) job.

In the AbstractSimQueueComposite_LocalStart, a (real) job can only be dropped because of one of the following two reasons:

• Its delegate job is dropped (autonomously) on one of the sub-queues, see processSubQueueNotifications(java.util.List<org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Notification<DJ, DQ>>). In this case, the delegate job has already left the sub-queue system when we are called, hence no action is required to remove it from there. All we have to do is invoke AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ).
• The composite queue (us) enforces dropping the job. In this case, the delegate job is may still be present on a sub-queue, and we have to forcibly revoke it on the sub-queue if so. We abuse removeJobFromQueueUponRevokation(J, double, boolean) to initiate the revocation (note that we cannot directly invoke AbstractSimQueue.revoke(double, J, boolean) or AbstractSimQueue.autoRevoke(double, J) on the composite queue as that would trigger an incorrect revocation notification).

Specified by:

removeJobFromQueueUponDrop in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that is to be dropped.

time - The current time (i.e., drop time of the job).

Throws:

IllegalStateException - If the real or delegate job does not exits.

See Also:

AbstractSimQueue.drop(J, double), rescheduleAfterDrop(J, double), removeJobFromQueueUponRevokation(J, double, boolean), AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ), AbstractSimQueueComposite.getDelegateJob(SimJob), SimJob.getQueue()

rescheduleAfterDrop

protected final void rescheduleAfterDrop(J job,
                                         double time)

Enforces the scheduled revocation on the sub-queue, if applicable.

Specified by:

rescheduleAfterDrop in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The jobs that was dropped.

time - The current time (i.e., drop time of the job).

See Also:

AbstractSimQueue.drop(J, double), removeJobFromQueueUponDrop(J, double), rescheduleAfterRevokation(J, double, boolean)

removeJobFromQueueUponRevokation

protected final void removeJobFromQueueUponRevokation(J job,
                                                      double time,
                                                      boolean auto)

Removes a job upon successful revocation (as determined by our super-class).

This method interacts delicately with rescheduleAfterRevokation(J, double, boolean) and the MultiSimQueueNotificationProcessor on the sub-queues, through the use of a pending revocation event (a local private field).

In a AbstractSimQueueComposite_LocalStart, revocations on real jobs can occur either through external requests, in other words, through AbstractSimQueue.revoke(double, J, boolean), or because of auto-revocations on the composite (this) queue through AbstractSimQueue.autoRevoke(double, J).

If the real job is still in the waiting area of the composite queue (without presence of the delegate job in any sub-queue), we suffice with cleaning up both real and delegate job through AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ) and we are finished.

Otherwise, the delegate job is still present on a sub-queue, and we have to forcibly revoke it. Because we cannot perform the revocation here (we are not allowed to reschedule!), we defer until removeJobFromQueueUponRevokation(J, double, boolean) by raising an internal flag (in fact a newly created, though not scheduled SimJQEvent.Revocation). We have to use this method in order to remember the delegate job to be revoked, and the queue from which to revoke it, both of which are wiped from the internal administration by AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ), which is invoked last.

Note that even though a SimJQEvent.Revocation is used internally to flag the required delegate-job revocation, it is never actually scheduled on the event list!

Specified by:

removeJobFromQueueUponRevokation in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that is to be revoked.

time - The current time (i.e., revocation time of the job).

auto - Whether or not this applies to an auto-revocation.

Throws:

IllegalStateException - If a pending delegate revocation has already been flagged (or been forgotten to clear).

See Also:

AbstractSimQueue.revoke(double, J, boolean), AbstractSimQueue.autoRevoke(double, J), SimJQEvent.Revocation, SimJQEvent.AutoRevocation, rescheduleAfterRevokation(J, double, boolean), AbstractSimQueueComposite.getDelegateJob(SimJob), SimJob.getQueue(), AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ)

rescheduleAfterRevokation

protected final void rescheduleAfterRevokation(J job,
                                               double time,
                                               boolean auto)

If present, performs the pending revocation on the applicable sub-queue, and check whether that succeeded.

This method interacts delicately with removeJobFromQueueUponRevokation(J, double, boolean) and the MultiSimQueueNotificationProcessor on the sub-queues, through the use of a pending revocation event (a local private field).

Upon return, the pending revocation event has been reset to null.

Specified by:

rescheduleAfterRevokation in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The jobs that was successfully revoked.

time - The current time (i.e., revocation time of the job).

auto - Whether or not this applies to an auto-revocation.

Throws:

IllegalStateException - If revoking the delegate job failed (as indicated by the failure to reset the pending revocation event by the sub-queue notification processor, see processSubQueueNotifications(java.util.List<org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Notification<DJ, DQ>>)).

Note that even though a SimJQEvent.Revocation is used internally to flag the required delegate-job revocation, it is never actually scheduled on the event list!

See Also:

AbstractSimQueue.revoke(double, J, boolean), AbstractSimQueue.autoRevoke(double, J), SimJQEvent.Revocation, SimJQEvent.AutoRevocation, removeJobFromQueueUponRevokation(J, double, boolean), processSubQueueNotifications(java.util.List<org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Notification<DJ, DQ>>)

setServerAccessCreditsSubClass

protected final void setServerAccessCreditsSubClass()

Takes appropriate action if needed on the server-access credits of sub-queues.

This method does nothing, since server-access credits with this model are managed locally.

Overrides:

setServerAccessCreditsSubClass in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

See Also:

AbstractSimQueue.setServerAccessCredits(double, int), rescheduleForNewServerAccessCredits(double)

rescheduleForNewServerAccessCredits

protected final void rescheduleForNewServerAccessCredits(double time)

Starts waiting jobs (in the local waiting area) as long as there are such jobs and there are (local) server-access credits available.

Specified by:

rescheduleForNewServerAccessCredits in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

time - The current time (i.e., the time at which new server-access credits became available).

See Also:

AbstractSimQueue.setServerAccessCredits(double, int), AbstractSimQueue.hasServerAcccessCredits(), AbstractSimQueue.hasJobsInWaitingArea(), AbstractSimQueue.start(double, J), AbstractSimQueue.getFirstJobInWaitingArea(), setServerAccessCreditsSubClass()

insertJobInQueueUponStart

protected final void insertJobInQueueUponStart(J job,
                                               double time)

Performs sanity chekcs.

Specified by:

insertJobInQueueUponStart in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that starts.

time - The current time (i.e., start time of the job).

Throws:

IllegalStateException - If sanity checks on internal consistency fail.

See Also:

AbstractSimQueue.start(double, J), rescheduleAfterStart(J, double)

rescheduleAfterStart

protected final void rescheduleAfterStart(J job,
                                          double time)

Lets the delegate job arrive at its first queue, or make it depart immediately if no such queue is provided.

This method selects the first sub-queue for the delegate job to arrive on through AbstractSimQueueComposite.selectFirstQueue(double, J). If a sub-queue is provided, it makes the delegate job arrive on that sub-queue; otherwise it invokes AbstractSimQueue.depart(double, J) on the real job.

Specified by:

rescheduleAfterStart in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job that started (and is already present in AbstractSimQueue.getJobsInServiceArea().

time - The current time (i.e., the start time of the job).

See Also:

AbstractSimQueue.start(double, J), AbstractSimQueueComposite.getDelegateJob(J), AbstractSimQueueComposite.selectFirstQueue(double, J), AbstractSimQueue.arrive(double, J), AbstractSimQueue.depart(double, J), AbstractSimQueueComposite.getQueue(java.util.Set<DQ>, int), insertJobInQueueUponStart(J, double)

getServiceTimeForJob

protected final double getServiceTimeForJob(J job)

Calls super method (in order to make implementation final).

Overrides:

getServiceTimeForJob in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

job - The job, non-null.

Returns:

The result from the super method.

removeJobFromQueueUponDeparture

protected final void removeJobFromQueueUponDeparture(J departingJob,
                                                     double time)

Departure of the given (real) job.

In the AbstractSimQueueComposite_LocalStart, a (real) job can only depart because of one of the following two reasons:

• Its delegate job departs (autonomously) on one of the sub-queues and there is no successor queue, see processSubQueueNotifications(java.util.List<org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Notification<DJ, DQ>>). In this case, the delegate job has already left the sub-queue system when we are called, hence no action is required to remove it from there. All we have to do is invoke AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ).
• The composite queue (us) enforces departure the job. In this case, the delegate job is may still be present on a sub-queue, and we have to forcibly revoke it on the sub-queue if so. We abuse removeJobFromQueueUponRevokation(J, double, boolean) to initiate the revocation (note that we cannot directly invoke AbstractSimQueue.revoke(double, J, boolean) or AbstractSimQueue.autoRevoke(double, J) on the composite queue as that would trigger an incorrect revocation notification).

Specified by:

removeJobFromQueueUponDeparture in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

departingJob - The job that departs.

time - The departure (current) time.

Throws:

IllegalStateException - If the real or delegate job does not exits.

See Also:

AbstractSimQueue.depart(double, J), rescheduleAfterDeparture(J, double), removeJobFromQueueUponRevokation(J, double, boolean), AbstractSimQueueComposite.removeJobsFromQueueLocal(J, DJ), AbstractSimQueueComposite.getDelegateJob(SimJob), SimJob.getQueue()

rescheduleAfterDeparture

protected final void rescheduleAfterDeparture(J departedJob,
                                              double time)

Enforces the scheduled revocation on the sub-queue, if applicable.

Specified by:

rescheduleAfterDeparture in class AbstractSimQueue<J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

departedJob - The departed job.

time - The departure (current) time.

See Also:

AbstractSimQueue.depart(double, J), removeJobFromQueueUponDeparture(J, double), rescheduleAfterRevokation(J, double, boolean)

processSubQueueNotifications

protected void processSubQueueNotifications(List<MultiSimQueueNotificationProcessor.Notification<DJ,DQ>> notifications)

Processes the pending atomic notifications from the sub-queues, one at a time (core sub-queue notification processor).

Core method for reacting to SimEntityListener.notifyStateChanged(double, org.javades.jqueues.r5.entity.SimEntity, java.util.List<java.util.Map<org.javades.jqueues.r5.entity.SimEntitySimpleEventType.Member, org.javades.jqueues.r5.entity.SimEntityEvent>>) notifications from all sub-queues. This method is registered as the processor for an anonymous MultiSimQueueNotificationProcessor (for all sub-queues) created upon construction, see MultiSimQueueNotificationProcessor.Processor and MultiSimQueueNotificationProcessor.setProcessor(org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Processor).

This method takes one notification at a time, starting at the head of the list, removes it, and processes the notification as described below. While processing, new notifications may be added to the list; the list is processed until it is empty.

However, before processing any event, it checks for SimEntitySimpleEventType.RESET (sub-)notifications. If it finds any, the notifications list is cleared and immediate return from this method follows. A reset event, however, is subjected to rigorous sanity checks; notably, it has to be an isolated atomic event. Failure of the sanity checks will lead to an IllegalStateException.

Otherwise, this method processes the notifications as described below; the remainder of the method is encapsulated in a AbstractSimEntity.clearAndUnlockPendingNotificationsIfLocked() and AbstractSimEntity.fireAndLockPendingNotifications() pair, to make sure we create atomic notifications in case of a top-level event.

A notification consists of a (fixed) sequence of sub-notifications, see MultiSimQueueNotificationProcessor.Notification.getSubNotifications(), each of which is processed in turn as follows:

• With SimEntitySimpleEventType.RESET, impossible, see above; throws an IllegalStateException.
• With queue-access vacation related events, SimQueueSimpleEventType.QUEUE_ACCESS_VACATION, SimQueueSimpleEventType.QAV_START, SimQueueSimpleEventType.QAV_END, we throw an IllegalStateException.
• With server-access credits related events SimQueueSimpleEventType.SERVER_ACCESS_CREDITS, SimQueueSimpleEventType.REGAINED_SAC, SimQueueSimpleEventType.OUT_OF_SAC, we throw an IllegalStateException.
• We ignore start-armed related events SimQueueSimpleEventType.STA_FALSE, SimQueueSimpleEventType.STA_TRUE, as these are dealt with (if at all) by the outer loop.
• With SimJQSimpleEventType.ARRIVAL, we do nothing.
• With SimJQSimpleEventType.DROP, we drop the real job through AbstractSimQueue.drop(J, double).
• With SimJQSimpleEventType.REVOCATION, we check for the presence of a corresponding real job through AbstractSimQueueComposite.getRealJob(DJ, DQ), and throw an IllegalStateException if we found one. Revocation notifications must always be the result of the composite queue's AbstractSimQueue.revoke(double, J, boolean) operation, and at this stage, the real job has already been removed from the composite queue. Subsequently, we perform sanity checks on the pending revocation event, again throwing an IllegalStateException in case of an error. If all is well, we simply clear the pending revocation event on the composite queue.
• With SimJQSimpleEventType.AUTO_REVOCATION, we throw an IllegalStateException.
• With SimJQSimpleEventType.START, we start the real job.
• With SimJQSimpleEventType.DEPARTURE, we invoke AbstractSimQueueComposite.selectNextQueue(double, J, DQ) on the real job, and let the delegate job arrive at the next queue if provided, or makes the real job depart if not through AbstractSimQueue.depart(double, J).
• With any non-standard notification type, we ignore the notification.

After all notifications have been processed, and the notification list is empty, we invoke AbstractSimQueue.triggerPotentialNewStartArmed(double) on the composite queue, in order to make sure we are not missing an autonomous change in SimQueue.isStartArmed() on a sub-queue. Since we do not expect any back-fire notifications from sub-queues from that method, we check again the notification list, and throw an exception if it is non-empty.

A full description of the sanity checks would make this entry uninterestingly large(r), hence we refer to the source code. Most checks are trivial checks on the allowed sub-notifications from the sub-queues and on the presence or absence of real and delegate jobs (and their expected presence or absence on a sub-queue).

Specified by:

processSubQueueNotifications in class AbstractSimQueueComposite<DJ extends SimJob,DQ extends SimQueue,J extends SimJob,Q extends AbstractSimQueueComposite_LocalStart>

Parameters:

notifications - The sub-queue notifications, will be modified; empty upon return.

Throws:

IllegalArgumentException - If the list is null or empty, or contains a notification from another queue than the a sub-queue, or if other sanity checks fail.

See Also:

MultiSimQueueNotificationProcessor, MultiSimQueueNotificationProcessor.Processor, MultiSimQueueNotificationProcessor.setProcessor(org.javades.jqueues.r5.listener.MultiSimQueueNotificationProcessor.Processor), SimEntitySimpleEventType.RESET, SimJQSimpleEventType.ARRIVAL, SimQueueSimpleEventType.QUEUE_ACCESS_VACATION, SimQueueSimpleEventType.QAV_START, SimQueueSimpleEventType.QAV_END, SimQueueSimpleEventType.SERVER_ACCESS_CREDITS, SimQueueSimpleEventType.OUT_OF_SAC, SimQueueSimpleEventType.REGAINED_SAC, SimQueueSimpleEventType.STA_FALSE, SimQueueSimpleEventType.STA_TRUE, SimJQSimpleEventType.DROP, SimJQSimpleEventType.REVOCATION, SimJQSimpleEventType.AUTO_REVOCATION, SimJQSimpleEventType.START, SimJQSimpleEventType.DEPARTURE, AbstractSimEntity.addPendingNotification(java.util.Map<org.javades.jqueues.r5.entity.SimEntitySimpleEventType.Member, org.javades.jqueues.r5.entity.SimEntityEvent>), SimQueue.arrive(double, J), AbstractSimQueue.start(double, J), AbstractSimQueueComposite.selectNextQueue(double, J, DQ), AbstractSimQueue.depart(double, J), AbstractSimQueue.triggerPotentialNewStartArmed(double), AbstractSimEntity.clearAndUnlockPendingNotificationsIfLocked(), AbstractSimEntity.fireAndLockPendingNotifications()