syncedclockstub.java

High performance DB query

/*
 * @(#)$Id: SyncedClockStub.java,v 1.4 2004/07/02 23:59:22 huebsch Exp $
 *
 * Copyright (c) 2001-2004 Regents of the University of California.
 * All rights reserved.
 *
 * This file is distributed under the terms in the attached BERKELEY-LICENSE
 * file. If you do not find these files, copies can be found by writing to:
 * Computer Science Division, Database Group, Universite of California,
 * 617 Soda Hall #1776, Berkeley, CA 94720-1776. Attention: Berkeley License
 *
 * Copyright (c) 2003-2004 Intel Corporation. All rights reserved.
 *
 * This file is distributed under the terms in the attached INTEL-LICENSE file.
 * If you do not find these files, copies can be found by writing to:
 * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300,
 * Berkeley, CA, 94704.  Attention:  Intel License Inquiry.
 */


package simulator.schedulers.clock.synced;

import java.util.HashMap;
import simulator.schedulers.clock.ClockClient;
import simulator.schedulers.clock.ClockStub;

/**
 * Class SyncedClockStub
 *
 */
public class SyncedClockStub implements ClockStub {

    private SyncedClockScheduler scheduler;
    private HashMap trackedEvents;

    /**
     * Constructor SyncedClockStub
     *
     * @param scheduler
     */
    public SyncedClockStub(SyncedClockScheduler scheduler) {
        this.scheduler = scheduler;
        trackedEvents = new HashMap();
    }

    /**
     * Method handleEvent
     *
     * @param theEvent
     */
    public void handleEvent(SyncedClockEvent theEvent) {
        if (theEvent.getTracked()) {
            trackedEvents.remove(new Long(theEvent.getEventID()));
        }

        theEvent.getClient().handleClock(theEvent.getData());
    }

    /**
     * Method getCurrentTime
     * @return
     */
    public double getCurrentTime() {
        return scheduler.getCurrentTime();
    }

    /**
     * Method schedule
     *
     * @param relativeTime
     * @param data
     * @param client
     */
    public void schedule(double relativeTime, Object data, ClockClient client) {
        scheduler.scheduleEvent(relativeTime, data, client, false);
    }

    /**
     * Method scheduleTracked
     *
     * @param relativeTime
     * @param data
     * @param client
     * @return
     */
    public Long scheduleTracked(double relativeTime, Object data,
                                ClockClient client) {
        SyncedClockEvent theEvent = scheduler.scheduleEvent(relativeTime, data,
                                        client, true);
        Long theEventID = new Long(theEvent.getEventID());

        trackedEvents.put(theEventID, theEvent);

        return theEventID;
    }

    /**
     * Method scheduleAbsolute
     *
     * @param absoluteTime
     * @param data
     * @param client
     */
    public void scheduleAbsolute(double absoluteTime, Object data,
                                 ClockClient client) {
        schedule(absoluteTime - getCurrentTime(), data, client);
    }

    /**
     * Method scheduleAbsoluteTracked
     *
     * @param absoluteTime
     * @param data
     * @param client
     * @return
     */
    public Long scheduleAbsoluteTracked(double absoluteTime, Object data,
                                        ClockClient client) {
        return scheduleTracked(absoluteTime - getCurrentTime(), data, client);
    }

    /**
     * Method deschedule
     *
     * @param eventID
     */
    public void deschedule(Long eventID) {
        SyncedClockEvent theEvent =
            (SyncedClockEvent) trackedEvents.remove(eventID);

        if (theEvent != null) {
            scheduler.descheduleEvent(theEvent);
        }
    }
}