public Timer() 
{

}

Default constructor.

 public synchronized Integer addNotification(String type,
    String message,
    Object userData,
    Date date) throws IllegalArgumentException 
{
        return (addNotification(type, message, userData, date, 0, 0));
}

Creates a new timer notification with the specified type, message and userData and inserts it into the list of notifications with a given date and a null period and number of occurrences.

The timer notification will be handled once at the specified date.

If the timer notification to be inserted has a date that is before the current date, the method behaves as if the specified date were the current date and the notification is delivered immediately.

 public synchronized Integer addNotification(String type,
    String message,
    Object userData,
    Date date,
    long period) throws IllegalArgumentException 
{
        return (addNotification(type, message, userData, date, period, 0));
}

Creates a new timer notification with the specified type, message and userData and inserts it into the list of notifications with a given date and period and a null number of occurrences.

The timer notification will repeat continuously using the timer period using a fixed-delay execution scheme, as specified in java.util.Timer . In order to use a fixed-rate execution scheme, use #addNotification(String, String, Object, Date, long, long, boolean) instead.

If the timer notification to be inserted has a date that is before the current date, the method behaves as if the specified date were the current date. The first notification is delivered immediately and the subsequent ones are spaced as specified by the period parameter.

 public synchronized Integer addNotification(String type,
    String message,
    Object userData,
    Date date,
    long period,
    long nbOccurences) throws IllegalArgumentException 
{
      return addNotification(type, message, userData, date, period, nbOccurences, false);
}

Creates a new timer notification with the specified type, message and userData and inserts it into the list of notifications with a given date, period and number of occurrences.

If the timer notification to be inserted has a date that is before the current date, the method behaves as if the specified date were the current date.
For once-off notifications, the notification is delivered immediately.
For periodic notifications, the first notification is delivered immediately and the subsequent ones are spaced as specified by the period parameter.

Note that once the timer notification has been added into the list of notifications, its associated date, period and number of occurrences cannot be updated.

In the case of a periodic notification, uses a fixed-delay execution scheme, as specified in java.util.Timer . In order to use a fixed-rate execution scheme, use #addNotification(String, String, Object, Date, long, long, boolean) instead.

 public synchronized Integer addNotification(String type,
    String message,
    Object userData,
    Date date,
    long period,
    long nbOccurences,
    boolean fixedRate) throws IllegalArgumentException 
{
        if (date == null) {
            throw new java.lang.IllegalArgumentException("Timer notification date cannot be null.");
        }
        // Check that all the timer notification attributes are valid.
        //
        // Invalid timer period value exception:
        // Check that the period and the nbOccurences are POSITIVE VALUES.
        //
        if ((period <  0) || (nbOccurences <  0)) {
            throw new java.lang.IllegalArgumentException("Negative values for the periodicity");
        }
        Date currentDate = new Date();
        // Update the date if it is before the current date.
        //
        if (currentDate.after(date)) {
            date.setTime(currentDate.getTime());
            if (TIMER_LOGGER.isLoggable(Level.FINER)) {
                TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                        "addNotification",
                        "update timer notification to add with:" +
                        "\n\tNotification date = " + date);
            }
        }
        // Create and add the timer notification into the timer table.
        //
        Integer notifID = Integer.valueOf(++counterID);
        // The sequenceNumber and the timeStamp attributes are updated
        // when the notification is emitted by the timer.
        //
        TimerNotification notif = new TimerNotification(type, this, 0, 0, message, notifID);
        notif.setUserData(userData);
        Object[] obj = new Object[6];
        TimerAlarmClock alarmClock;
        if (fixedRate)
        {
          alarmClock = new TimerAlarmClock(this, date);
        }
        else
        {
          alarmClock = new TimerAlarmClock(this, (date.getTime() - currentDate.getTime()));
        }
        // Fix bug 00417.B
        // The date registered into the timer is a clone from the date parameter.
        //
        Date d = new Date(date.getTime());
        obj[TIMER_NOTIF_INDEX] = (Object)notif;
        obj[TIMER_DATE_INDEX] = (Object)d;
        obj[TIMER_PERIOD_INDEX] = (Object) period;
        obj[TIMER_NB_OCCUR_INDEX] = (Object) nbOccurences;
        obj[ALARM_CLOCK_INDEX] = (Object)alarmClock;
        obj[FIXED_RATE_INDEX] = Boolean.valueOf(fixedRate);
        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
            StringBuilder strb = new StringBuilder()
            .append("adding timer notification:\n\t")
            .append("Notification source = ")
            .append(notif.getSource())
            .append("\n\tNotification type = ")
            .append(notif.getType())
            .append("\n\tNotification ID = ")
            .append(notifID)
            .append("\n\tNotification date = ")
            .append(d)
            .append("\n\tNotification period = ")
            .append(period)
            .append("\n\tNotification nb of occurrences = ")
            .append(nbOccurences)
            .append("\n\tNotification executes at fixed rate = ")
            .append(fixedRate);
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "addNotification", strb.toString());
        }
        timerTable.put(notifID, obj);
        // Update and start the TimerAlarmClock.
        //
        if (isActive == true) {
          if (fixedRate)
          {
            timer.schedule(alarmClock, alarmClock.next);
          }
          else
          {
            timer.schedule(alarmClock, alarmClock.timeout);
          }
        }
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "addNotification", "timer notification added");
        return notifID;
}

Creates a new timer notification with the specified type, message and userData and inserts it into the list of notifications with a given date, period and number of occurrences.

If the timer notification to be inserted has a date that is before the current date, the method behaves as if the specified date were the current date.
For once-off notifications, the notification is delivered immediately.
For periodic notifications, the first notification is delivered immediately and the subsequent ones are spaced as specified by the period parameter.

Note that once the timer notification has been added into the list of notifications, its associated date, period and number of occurrences cannot be updated.

In the case of a periodic notification, the value of parameter fixedRate is used to specify the execution scheme, as specified in java.util.Timer .

 public synchronized Vector<Integer> getAllNotificationIDs() 
{
        return new Vector< Integer >(timerTable.keySet());
}

Gets all timer notification identifiers registered into the list of notifications.

 public Date getDate(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            Date date = (Date)obj[TIMER_DATE_INDEX];
            return (new Date(date.getTime()));
        }
        return null;
}

Gets a copy of the date associated to a timer notification.

 public Boolean getFixedRate(Integer id) 
{
      Object[] obj = timerTable.get(id);
      if (obj != null) {
        Boolean fixedRate = (Boolean)obj[FIXED_RATE_INDEX];
        return (Boolean.valueOf(fixedRate.booleanValue()));
      }
      return null;
}

Gets a copy of the flag indicating whether a periodic notification is executed at fixed-delay or at fixed-rate.

 public int getNbNotifications() 
{
        return timerTable.size();
}

Gets the number of timer notifications registered into the list of notifications.

 public Long getNbOccurences(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            return (Long)obj[TIMER_NB_OCCUR_INDEX];
        }
        return null;
}

Gets a copy of the remaining number of occurrences associated to a timer notification.

 public synchronized Vector<Integer> getNotificationIDs(String type) 
{
        String s;
        Vector< Integer > v = new Vector< Integer >();
        for (Map.Entry< Integer,Object[] > entry : timerTable.entrySet()) {
            Object[] obj = entry.getValue();
            s = ((TimerNotification)obj[TIMER_NOTIF_INDEX]).getType();
            if ((type == null) ? s == null : type.equals(s))
                v.addElement(entry.getKey());
        }
        return v;
}

Gets all the identifiers of timer notifications corresponding to the specified type.

 public synchronized MBeanNotificationInfo[] getNotificationInfo() 
{
        Set< String > notifTypes = new TreeSet< String >();
        for (Object[] entry : timerTable.values()) {
            TimerNotification notif = (TimerNotification)
                entry[TIMER_NOTIF_INDEX];
            notifTypes.add(notif.getType());
        }
        String[] notifTypesArray =
            notifTypes.toArray(new String[0]);
        return new MBeanNotificationInfo[] {
            new MBeanNotificationInfo(notifTypesArray,
                                      TimerNotification.class.getName(),
                                      "Notification sent by Timer MBean")
        };
}

 public String getNotificationMessage(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            return ( ((TimerNotification)obj[TIMER_NOTIF_INDEX]).getMessage() );
        }
        return null;
}

Gets the timer notification detailed message corresponding to the specified identifier.

 public String getNotificationType(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            return ( ((TimerNotification)obj[TIMER_NOTIF_INDEX]).getType() );
        }
        return null;
}

Gets the timer notification type corresponding to the specified identifier.

 public Object getNotificationUserData(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            return ( ((TimerNotification)obj[TIMER_NOTIF_INDEX]).getUserData() );
        }
        return null;
}

Gets the timer notification user data object corresponding to the specified identifier.

 public Long getPeriod(Integer id) 
{
        Object[] obj = timerTable.get(id);
        if (obj != null) {
            return (Long)obj[TIMER_PERIOD_INDEX];
        }
        return null;
}

Gets a copy of the period (in milliseconds) associated to a timer notification.

 public boolean getSendPastNotifications() 
{
        return sendPastNotifications;
}

Gets the flag indicating whether or not the timer sends past notifications.
The default value of the past notifications sending on/off flag is false.

 public boolean isActive() 
{
        return isActive;
}

Tests whether the timer MBean is active. A timer MBean is marked active when the start method is called. It becomes inactive when the stop method is called.
The default value of the active on/off flag is false.

 public boolean isEmpty() 
{
        return (timerTable.isEmpty());
}

Tests whether the list of timer notifications is empty.

  void notifyAlarmClock(TimerAlarmClockNotification notification) 
{
        TimerNotification timerNotification = null;
        Date timerDate = null;
        // Retrieve the timer notification associated to the alarm-clock.
        //
        TimerAlarmClock alarmClock = (TimerAlarmClock)notification.getSource();
        for (Object[] obj : timerTable.values()) {
            if (obj[ALARM_CLOCK_INDEX] == alarmClock) {
                timerNotification = (TimerNotification)obj[TIMER_NOTIF_INDEX];
                timerDate = (Date)obj[TIMER_DATE_INDEX];
                break;
            }
        }
        // Notify the timer.
        //
        sendNotification(timerDate, timerNotification);
        // Update the notification and the TimerAlarmClock timeout.
        //
        updateTimerTable(timerNotification.getNotificationID());
}

This method is called by the timer each time the TimerAlarmClock has exceeded its timeout.

 public  void postDeregister() 
{

}

Allows the timer MBean to perform any operations needed after having been unregistered by the MBean server.

Not used in this context.

 public  void postRegister(Boolean registrationDone) 
{

}

Allows the timer MBean to perform any operations needed after having been registered in the MBean server or after the registration has failed.

Not used in this context.

 public  void preDeregister() throws Exception 
{
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "preDeregister", "stop the timer");
        // Stop the timer.
        //
        stop();
}

Allows the timer MBean to perform any operations it needs before being unregistered by the MBean server.

Stops the timer.

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
        return name;
}

Allows the timer MBean to perform any operations it needs before being registered in the MBean server.

Not used in this context.

 public synchronized  void removeAllNotifications() 
{
        TimerAlarmClock alarmClock;
        for (Object[] obj : timerTable.values()) {
            // Stop the TimerAlarmClock.
            //
            alarmClock = (TimerAlarmClock)obj[ALARM_CLOCK_INDEX];
//             if (alarmClock != null) {
//                 alarmClock.interrupt();
//                 try {
//                     // Wait until the thread die.
//                     //
//                     alarmClock.join();
//                 } catch (InterruptedException ex) {
//                     // Ignore...
//                 }
                  // Remove the reference on the TimerAlarmClock.
                  //
//             }
            alarmClock.cancel();
        }
        // Remove all the timer notifications from the timer table.
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "removeAllNotifications", "removing all timer notifications");
        timerTable.clear();
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "removeAllNotifications", "all timer notifications removed");
        // Reset the counterID.
        //
        counterID = 0;
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "removeAllNotifications", "timer notification counter ID reset");
}

Removes all the timer notifications from the list of notifications and resets the counter used to update the timer notification identifiers.

 public synchronized  void removeNotification(Integer id) throws InstanceNotFoundException 
{
        // Check that the notification to remove is effectively in the timer table.
        //
        if (timerTable.containsKey(id) == false) {
            throw new InstanceNotFoundException("Timer notification to remove not in the list of notifications");
        }
        // Stop the TimerAlarmClock.
        //
        Object[] obj = timerTable.get(id);
        TimerAlarmClock alarmClock = (TimerAlarmClock)obj[ALARM_CLOCK_INDEX];
        if (alarmClock != null) {
//             alarmClock.interrupt();
//             try {
//                 // Wait until the thread die.
//                 //
//                 alarmClock.join();
//             } catch (InterruptedException e) {
//                 // Ignore...
//             }
//             // Remove the reference on the TimerAlarmClock.
//             //
            alarmClock.cancel();
        }
        // Remove the timer notification from the timer table.
        //
        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
            StringBuilder strb = new StringBuilder()
            .append("removing timer notification:")
            .append("\n\tNotification source = ")
            .append(((TimerNotification)obj[TIMER_NOTIF_INDEX]).getSource())
            .append("\n\tNotification type = ")
            .append(((TimerNotification)obj[TIMER_NOTIF_INDEX]).getType())
            .append("\n\tNotification ID = ")
            .append(((TimerNotification)obj[TIMER_NOTIF_INDEX]).getNotificationID())
            .append("\n\tNotification date = ")
            .append(obj[TIMER_DATE_INDEX])
            .append("\n\tNotification period = ")
            .append(obj[TIMER_PERIOD_INDEX])
            .append("\n\tNotification nb of occurrences = ")
            .append(obj[TIMER_NB_OCCUR_INDEX])
            .append("\n\tNotification executes at fixed rate = ")
            .append(obj[FIXED_RATE_INDEX]);
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "removeNotification", strb.toString());
        }
        timerTable.remove(id);
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "removeNotification", "timer notification removed");
}

Removes the timer notification corresponding to the specified identifier from the list of notifications.

 public synchronized  void removeNotifications(String type) throws InstanceNotFoundException 
{
        Vector< Integer > v = getNotificationIDs(type);
        if (v.isEmpty())
            throw new InstanceNotFoundException("Timer notifications to remove not in the list of notifications");
        for (Integer i : v)
            removeNotification(i);
}

Removes all the timer notifications corresponding to the specified type from the list of notifications.

  void sendNotification(Date timeStamp,
    TimerNotification notification) 
{
        if (TIMER_LOGGER.isLoggable(Level.FINER)) {
            StringBuilder strb = new StringBuilder()
            .append("sending timer notification:")
            .append("\n\tNotification source = ")
            .append(notification.getSource())
            .append("\n\tNotification type = ")
            .append(notification.getType())
            .append("\n\tNotification ID = ")
            .append(notification.getNotificationID())
            .append("\n\tNotification date = ")
            .append(timeStamp);
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "sendNotification", strb.toString());
        }
        long curSeqNumber;
        synchronized(this) {
            sequenceNumber = sequenceNumber + 1;
            curSeqNumber = sequenceNumber;
        }
        synchronized (notification) {
            notification.setTimeStamp(timeStamp.getTime());
            notification.setSequenceNumber(curSeqNumber);
            this.sendNotification((TimerNotification)notification.cloneTimerNotification());
        }
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "sendNotification", "timer notification sent");
}

This method is used by the timer MBean to update and send a timer notification to all the listeners registered for this kind of notification.

 public  void setSendPastNotifications(boolean value) 
{
        sendPastNotifications = value;
}

Sets the flag indicating whether the timer sends past notifications or not.
The default value of the past notifications sending on/off flag is false.

 public synchronized  void start() 
{
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "start", "starting the timer");
        // Start the TimerAlarmClock.
        //
        if (isActive == false) {
            timer = new java.util.Timer();
            TimerAlarmClock alarmClock;
            Date date;
            Date currentDate = new Date();
            // Send or not past notifications depending on the flag.
            // Update the date and the number of occurrences of past notifications
            // to make them later than the current date.
            //
            sendPastNotifications(currentDate, sendPastNotifications);
            // Update and start all the TimerAlarmClocks.
            // Here, all the notifications in the timer table are later than the current date.
            //
            for (Object[] obj : timerTable.values()) {
                // Retrieve the date notification and the TimerAlarmClock.
                //
                date = (Date)obj[TIMER_DATE_INDEX];
                // Update all the TimerAlarmClock timeouts and start them.
                //
                boolean fixedRate = ((Boolean)obj[FIXED_RATE_INDEX]).booleanValue();
                if (fixedRate)
                {
                  alarmClock = new TimerAlarmClock(this, date);
                  obj[ALARM_CLOCK_INDEX] = (Object)alarmClock;
                  timer.schedule(alarmClock, alarmClock.next);
                }
                else
                {
                  alarmClock = new TimerAlarmClock(this, (date.getTime() - currentDate.getTime()));
                  obj[ALARM_CLOCK_INDEX] = (Object)alarmClock;
                  timer.schedule(alarmClock, alarmClock.timeout);
                }
            }
            // Set the state to ON.
            //
            isActive = true;
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "start", "timer started");
        } else {
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "start", "the timer is already activated");
        }
}

Starts the timer.

If there is one or more timer notifications before the time in the list of notifications, the notification is sent according to the sendPastNotifications flag and then, updated according to its period and remaining number of occurrences. If the timer notification date remains earlier than the current date, this notification is just removed from the list of notifications.

 public synchronized  void stop() 
{
        TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                "stop", "stopping the timer");
        // Stop the TimerAlarmClock.
        //
        if (isActive == true) {
            for (Object[] obj : timerTable.values()) {
                // Stop all the TimerAlarmClock.
                //
                TimerAlarmClock alarmClock = (TimerAlarmClock)obj[ALARM_CLOCK_INDEX];
                if (alarmClock != null) {
//                     alarmClock.interrupt();
//                     try {
//                         // Wait until the thread die.
//                         //
//                         alarmClock.join();
//                     } catch (InterruptedException ex) {
//                         // Ignore...
//                     }
//                     // Remove the reference on the TimerAlarmClock.
//                     //
                    alarmClock.cancel();
                }
            }
            timer.cancel();
            // Set the state to OFF.
            //
            isActive = false;
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "stop", "timer stopped");
        } else {
            TIMER_LOGGER.logp(Level.FINER, Timer.class.getName(),
                    "stop", "the timer is already deactivated");
        }
}

Stops the timer.