/**
* The ... class ...
*
* <p>Created by scmijt Date: Nov 28, 2007 Time: 1:15:49 PM
*/
public class AgentJEventQueue {
private static ConcurrentLinkedQueue<AgentJEventObject> events =
new ConcurrentLinkedQueue<AgentJEventObject>();
static Logger logger = Log.getLogger(Controller.class);
private static final AgentJEventQueue instance = new AgentJEventQueue();
private AgentJEventQueue() {} // One is enough - singleton
public static AgentJEventQueue getInstance() {
return instance;
}
/** Pushes a send instruction onto the FIFO queue (either TCP or UDP). */
public static void pushEvent(AgentJEventObjectInterface source, Object payload) {
events.add(new AgentJEventObject(source, payload));
}
/**
* Pops all of the elements off the queue and executes each event in turn. This results in the
* sending of the data
*
* @return number of events popped
*/
public static int popEvents() {
int eventsPopped = 0;
AgentJEventObject jobject;
while ((jobject = events.poll()) != null) {
try {
jobject.getSource().doSend(jobject.getPayload());
} catch (IOException e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
++eventsPopped;
}
return eventsPopped;
}
}
/**
* A task that can be scheduled for one-time or repeated execution by a Timer.
*
* @author Josh Bloch
* @version 1.10, 02/19/04
* @see Timer
* @since 1.3
*/
public abstract class TimerTask implements Runnable, ProtolibTimerListener {
private static Logger logger = Log.getLogger(TimerTask.class);
private Timer timer = null;
/** The state of this task, chosen from the constants below. */
int state = VIRGIN;
/** This task has not yet been scheduled. */
static final int VIRGIN = 0;
/**
* This task is scheduled for execution. If it is a non-repeating task, it has not yet been
* executed.
*/
static final int SCHEDULED = 1;
/**
* This non-repeating task has already executed (or is currently executing) and has not been
* cancelled.
*/
static final int EXECUTED = 2;
/** This task has been cancelled (with a call to TimerTask.cancel). */
static final int CANCELLED = 3;
/**
* Next execution time for this task in the format returned by System.currentTimeMillis, assuming
* this task is scheduled for execution. For repeating tasks, this field is updated prior to each
* task execution.
*/
long nextExecutionTime;
/**
* Period in milliseconds for repeating tasks. A positive value indicates fixed-rate execution. A
* negative value indicates fixed-delay execution. A value of 0 indicates a non-repeating task.
*/
long period = 0;
/** Creates a new timer task. */
protected TimerTask() {}
/** The action to be performed by this timer task. */
public abstract void run();
/**
* Cancels this timer task. If the task has been scheduled for one-time execution and has not yet
* run, or has not yet been scheduled, it will never run. If the task has been scheduled for
* repeated execution, it will never run again. (If the task is running when this call occurs, the
* task will run to completion, but will never run again.)
*
* <p>Note that calling this method from within the <tt>run</tt> method of a repeating timer task
* absolutely guarantees that the timer task will not run again.
*
* <p>This method may be called repeatedly; the second and subsequent calls have no effect.
*
* @return true if this task is scheduled for one-time execution and has not yet run, or this task
* is scheduled for repeated execution. Returns false if the task was scheduled for one-time
* execution and has already run, or if the task was never scheduled, or if the task was
* already cancelled. (Loosely speaking, this method returns <tt>true</tt> if it prevents one
* or more scheduled executions from taking place.)
*/
public boolean cancel() {
boolean result = (state == SCHEDULED);
state = CANCELLED;
return result;
}
/**
* Returns the <i>scheduled</i> execution time of the most recent <i>actual</i> execution of this
* task. (If this method is invoked while task execution is in progress, the return value is the
* scheduled execution time of the ongoing task execution.)
*
* <p>This method is typically invoked from within a task's run method, to determine whether the
* current execution of the task is sufficiently timely to warrant performing the scheduled
* activity:
*
* <pre>
* public void run() {
* if (System.currentTimeMillis() - scheduledExecutionTime() >=
* MAX_TARDINESS)
* return; // Too late; skip this execution.
* // Perform the task
* }
* </pre>
*
* This method is typically <i>not</i> used in conjunction with <i>fixed-delay execution</i>
* repeating tasks, as their scheduled execution times are allowed to drift over time, and so are
* not terribly significant.
*
* @return the time at which the most recent execution of this task was scheduled to occur, in the
* format returned by Date.getTime(). The return value is undefined if the task has yet to
* commence its first execution.
* @see Date#getTime()
*/
public long scheduledExecutionTime() {
return (period < 0 ? nextExecutionTime + period : nextExecutionTime - period);
}
/** This is called by the ProtolibTimer */
public void timeOut() {
logger.trace("javm/util/TimerTask: timeOut entered");
if (state == CANCELLED) {
logger.trace("javm/util/TimerTask: I have been cancelled -- timeOut left");
timer.removeTimerTask(this);
return;
}
Controller controller = AgentJVirtualMachine.getCurrentNS2NodeController();
run();
logger.trace("TimerTask.java: run() left");
if (period != 0) {
logger.trace("javm/util/TimerTask: new Timer created");
nextExecutionTime += Math.abs(period);
ProtolibTimer protoTimer =
new ProtolibTimer(controller, (double) Math.abs(period) / 1000.0, 0);
protoTimer.startTimerAndNotifyOnTimeout(this);
logger.trace("javm/util/TimerTask: new Timer created sucessfully");
} else { // non-repeating task
state = EXECUTED;
timer.removeTimerTask(this);
}
logger.trace("javm/util/TimerTask: timeOut left");
}
public void setTimer(Timer timer) {
this.timer = timer;
}
}