public RAMJobStore() 
{
    /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     * 
     * Constructors.
     * 
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */
}

Create a new RAMJobStore.

 public Trigger acquireNextTrigger(SchedulingContext ctxt,
    long noLaterThan) 
{
        TriggerWrapper tw = null;
        synchronized (triggerLock) {
            while (tw == null) {
                try {
                    tw = (TriggerWrapper) timeTriggers.first();
                } catch (java.util.NoSuchElementException nsee) {
                    return null;
                }
                if (tw == null) {
                    return null;
                }
                if (tw.trigger.getNextFireTime() == null) {
                    timeTriggers.remove(tw);
                    tw = null;
                    continue;
                }
                timeTriggers.remove(tw);
                if (applyMisfire(tw)) {
                    if (tw.trigger.getNextFireTime() != null) {
                        timeTriggers.add(tw);
                    }
                    tw = null;
                    continue;
                }
                if(tw.trigger.getNextFireTime().getTime()  > noLaterThan) {
                    timeTriggers.add(tw);
                    return null;
                }
                tw.state = TriggerWrapper.STATE_ACQUIRED;
                tw.trigger.setFireInstanceId(getFiredTriggerRecordId());
                Trigger trig = (Trigger) tw.trigger.clone();
                return trig;
            }
        }
        return null;
}

Get a handle to the next trigger to be fired, and mark it as 'reserved' by the calling scheduler.

 protected boolean applyMisfire(TriggerWrapper tw) 
{
        long misfireTime = System.currentTimeMillis();
        if (getMisfireThreshold()  > 0) {
            misfireTime -= getMisfireThreshold();
        }
        java.util.Date tnft = tw.trigger.getNextFireTime();
        if (tnft.getTime()  > misfireTime) { return false; }
        Calendar cal = null;
        if (tw.trigger.getCalendarName() != null) {
            cal = retrieveCalendar(null, tw.trigger.getCalendarName());
        }
        signaler.notifyTriggerListenersMisfired((Trigger)tw.trigger.clone());
        tw.trigger.updateAfterMisfire(cal);
        if (tw.trigger.getNextFireTime() == null) {
            tw.state = TriggerWrapper.STATE_COMPLETE;
            synchronized (triggerLock) {
                timeTriggers.remove(tw);
            }
        } else if (tnft.equals(tw.trigger.getNextFireTime())) {
            return false;
        }
        return true;
}

 public String[] getCalendarNames(SchedulingContext ctxt) 
{
        Set names = calendarsByName.keySet();
        return (String[]) names.toArray(new String[names.size()]);
}

Get the names of all of the org.quartz.Calendar s in the JobStore.

If there are no Calendars in the given group name, the result should be a zero-length array (not null).

 protected synchronized String getFiredTriggerRecordId() 
{
        
        return String.valueOf(ftrCtr++);
}

 public String[] getJobGroupNames(SchedulingContext ctxt) 
{
        String[] outList = null;
        synchronized (jobLock) {
            outList = new String[jobsByGroup.size()];
            int outListPos = 0;
            Iterator keys = jobsByGroup.keySet().iterator();
            while (keys.hasNext()) {
                outList[outListPos++] = (String) keys.next();
            }
        }
        return outList;
}

Get the names of all of the org.quartz.Job groups.

 public String[] getJobNames(SchedulingContext ctxt,
    String groupName) 
{
        String[] outList = null;
        HashMap grpMap = (HashMap) jobsByGroup.get(groupName);
        if (grpMap != null) {
            synchronized (jobLock) {
                outList = new String[grpMap.size()];
                int outListPos = 0;
                for (Iterator valueIter = grpMap.values().iterator(); valueIter.hasNext();) {
                    JobWrapper jw = (JobWrapper)valueIter.next();
                    if (jw != null) {
                        outList[outListPos++] = jw.jobDetail.getName();
                    }
                }
            }
        } else {
            outList = new String[0];
        }
        return outList;
}

Get the names of all of the org.quartz.Job s that have the given group name.

 protected Log getLog() 
{
        return log;
}

 public long getMisfireThreshold() 
{
        return misfireThreshold;
}

 public int getNumberOfCalendars(SchedulingContext ctxt) 
{
        return calendarsByName.size();
}

Get the number of org.quartz.Calendar s that are stored in the JobsStore.

 public int getNumberOfJobs(SchedulingContext ctxt) 
{
        return jobsByFQN.size();
}

Get the number of org.quartz.JobDetail s that are stored in the JobsStore.

 public int getNumberOfTriggers(SchedulingContext ctxt) 
{
        return triggers.size();
}

Get the number of org.quartz.Trigger s that are stored in the JobsStore.

 public Set getPausedTriggerGroups(SchedulingContext ctxt) throws JobPersistenceException 
{
        HashSet set = new HashSet();
        set.addAll(pausedTriggerGroups);
        return set;
}

 public String[] getTriggerGroupNames(SchedulingContext ctxt) 
{
        String[] outList = null;
        synchronized (triggerLock) {
            outList = new String[triggersByGroup.size()];
            int outListPos = 0;
            Iterator keys = triggersByGroup.keySet().iterator();
            while (keys.hasNext()) {
                outList[outListPos++] = (String) keys.next();
            }
        }
        return outList;
}

Get the names of all of the org.quartz.Trigger groups.

 public String[] getTriggerNames(SchedulingContext ctxt,
    String groupName) 
{
        String[] outList = null;
        HashMap grpMap = (HashMap) triggersByGroup.get(groupName);
        if (grpMap != null) {
            synchronized (triggerLock) {
                outList = new String[grpMap.size()];
                int outListPos = 0;
                for (Iterator valueIter = grpMap.values().iterator(); valueIter.hasNext();) {
                    TriggerWrapper tw = (TriggerWrapper) valueIter.next();
                    if (tw != null) {
                        outList[outListPos++] = tw.trigger.getName();
                    }
                }
            }
        } else {
            outList = new String[0];
        }
        return outList;
}

Get the names of all of the org.quartz.Trigger s that have the given group name.

 public int getTriggerState(SchedulingContext ctxt,
    String triggerName,
    String groupName) throws JobPersistenceException 
{
        TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                .getTriggerNameKey(triggerName, groupName));
        if (tw == null) {
            return Trigger.STATE_NONE;
        }
        if (tw.state == TriggerWrapper.STATE_COMPLETE) {
            return Trigger.STATE_COMPLETE;
        }
        if (tw.state == TriggerWrapper.STATE_PAUSED) {
            return Trigger.STATE_PAUSED;
        }
        if (tw.state == TriggerWrapper.STATE_PAUSED_BLOCKED) {
            return Trigger.STATE_PAUSED;
        }
        if (tw.state == TriggerWrapper.STATE_BLOCKED) {
            return Trigger.STATE_BLOCKED;
        }
        if (tw.state == TriggerWrapper.STATE_ERROR) {
            return Trigger.STATE_ERROR;
        }
        return Trigger.STATE_NORMAL;
}

Get the current state of the identified Trigger .

 protected ArrayList getTriggerWrappersForCalendar(String calName) 
{
        ArrayList trigList = new ArrayList();
        synchronized (triggerLock) {
            for (int i = 0; i <  triggers.size(); i++) {
                TriggerWrapper tw = (TriggerWrapper) triggers.get(i);
                String tcalName = tw.getTrigger().getCalendarName();
                if (tcalName != null && tcalName.equals(calName)) {
                    trigList.add(tw);
                }
            }
        }
        return trigList;
}

 protected ArrayList getTriggerWrappersForJob(String jobName,
    String groupName) 
{
        ArrayList trigList = new ArrayList();
        String jobKey = JobWrapper.getJobNameKey(jobName, groupName);
        synchronized (triggerLock) {
            for (int i = 0; i <  triggers.size(); i++) {
                TriggerWrapper tw = (TriggerWrapper) triggers.get(i);
                if (tw.jobKey.equals(jobKey)) {
                    trigList.add(tw);
                }
            }
        }
        return trigList;
}

 public Trigger[] getTriggersForJob(SchedulingContext ctxt,
    String jobName,
    String groupName) 
{
        ArrayList trigList = new ArrayList();
        String jobKey = JobWrapper.getJobNameKey(jobName, groupName);
        synchronized (triggerLock) {
            for (int i = 0; i <  triggers.size(); i++) {
                TriggerWrapper tw = (TriggerWrapper) triggers.get(i);
                if (tw.jobKey.equals(jobKey)) {
                    trigList.add(tw.trigger.clone());
                }
            }
        }
        return (Trigger[]) trigList.toArray(new Trigger[trigList.size()]);
}

Get all of the Triggers that are associated to the given Job.

If there are no matches, a zero-length array should be returned.

 public  void initialize(ClassLoadHelper loadHelper,
    SchedulerSignaler signaler) 
{
        this.signaler = signaler;
        getLog().info("RAMJobStore initialized.");
}

Called by the QuartzScheduler before the JobStore is used, in order to give the it a chance to initialize.

 public  void pauseAll(SchedulingContext ctxt) 
{
        synchronized (pausedTriggerGroups) {
            String[] names = getTriggerGroupNames(ctxt);
            for (int i = 0; i <  names.length; i++) {
                pauseTriggerGroup(ctxt, names[i]);
            }
        }
}

Pause all triggers - equivalent of calling pauseTriggerGroup(group) on every group.

When resumeAll() is called (to un-pause), trigger misfire instructions WILL be applied.

 public  void pauseJob(SchedulingContext ctxt,
    String jobName,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            Trigger[] triggers = getTriggersForJob(ctxt, jobName, groupName);
            for (int j = 0; j <  triggers.length; j++) {
                pauseTrigger(ctxt, triggers[j].getName(), triggers[j].getGroup());
            }
        }
}

Pause the org.quartz.JobDetail with the given name - by pausing all of its current Triggers.

 public  void pauseJobGroup(SchedulingContext ctxt,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            String[] jobNames = getJobNames(ctxt, groupName);
            for (int i = 0; i <  jobNames.length; i++) {
                Trigger[] triggers = getTriggersForJob(ctxt, jobNames[i],
                        groupName);
                for (int j = 0; j <  triggers.length; j++) {
                    pauseTrigger(ctxt, triggers[j].getName(),
                            triggers[j].getGroup());
                }
            }
        }
}

Pause all of the org.quartz.JobDetail s in the given group - by pausing all of their Triggers.

The JobStore should "remember" that the group is paused, and impose the pause on any new jobs that are added to the group while the group is paused.

 public  void pauseTrigger(SchedulingContext ctxt,
    String triggerName,
    String groupName) 
{
        TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                .getTriggerNameKey(triggerName, groupName));
        // does the trigger exist?
        if (tw == null || tw.trigger == null) {
            return;
        }
        // if the trigger is "complete" pausing it does not make sense...
        if (tw.state == TriggerWrapper.STATE_COMPLETE) {
            return;
        }
        synchronized (triggerLock) {
            if(tw.state == TriggerWrapper.STATE_BLOCKED) {
                tw.state = TriggerWrapper.STATE_PAUSED_BLOCKED;
            } else {
                tw.state = TriggerWrapper.STATE_PAUSED;
            }
            timeTriggers.remove(tw);
        }
}

Pause the Trigger with the given name.

 public  void pauseTriggerGroup(SchedulingContext ctxt,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            if (pausedTriggerGroups.contains(groupName)) {
                return;
            }
            pausedTriggerGroups.add(groupName);
            String[] names = getTriggerNames(ctxt, groupName);
            for (int i = 0; i <  names.length; i++) {
                pauseTrigger(ctxt, names[i], groupName);
            }
        }
}

Pause all of the Trigger s in the given group.

The JobStore should "remember" that the group is paused, and impose the pause on any new triggers that are added to the group while the group is paused.

 protected String peekTriggers() 
{
        StringBuffer str = new StringBuffer();
        TriggerWrapper tw = null;
        synchronized (triggerLock) {
            for (Iterator valueIter = triggersByFQN.values().iterator(); valueIter.hasNext();) {
                tw = (TriggerWrapper)valueIter.next();
                str.append(tw.trigger.getName());
                str.append("/");
            }
        }
        str.append(" | ");
        synchronized (triggerLock) {
            Iterator itr = timeTriggers.iterator();
            while (itr.hasNext()) {
                tw = (TriggerWrapper) itr.next();
                str.append(tw.trigger.getName());
                str.append("- >");
            }
        }
        return str.toString();
}

 public  void releaseAcquiredTrigger(SchedulingContext ctxt,
    Trigger trigger) 
{
        synchronized (triggerLock) {
            TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                .getTriggerNameKey(trigger));
            if (tw != null && tw.state == TriggerWrapper.STATE_ACQUIRED) {
                tw.state = TriggerWrapper.STATE_WAITING;
                timeTriggers.add(tw);
            }
        }
}

Inform the JobStore that the scheduler no longer plans to fire the given Trigger, that it had previously acquired (reserved).

 public boolean removeCalendar(SchedulingContext ctxt,
    String calName) throws JobPersistenceException 
{
        int numRefs = 0;
        synchronized (triggerLock) {
            Iterator itr = triggers.iterator();
            while (itr.hasNext()) {
                Trigger trigg = ((TriggerWrapper) itr.next()).trigger;
                if (trigg.getCalendarName() != null
                        && trigg.getCalendarName().equals(calName)) {
                    numRefs++;
                }
            }
        }
        if (numRefs  > 0) {
            throw new JobPersistenceException(
                    "Calender cannot be removed if it referenced by a Trigger!");
        }
        return (calendarsByName.remove(calName) != null);
}

Remove (delete) the org.quartz.Calendar with the given name.

If removal of the Calendar would result in s pointing to non-existent calendars, then a JobPersistenceException will be thrown.

*

 public boolean removeJob(SchedulingContext ctxt,
    String jobName,
    String groupName) 
{
        String key = JobWrapper.getJobNameKey(jobName, groupName);
        boolean found = false;
        Trigger[] trigger = getTriggersForJob(ctxt, jobName,
                groupName);
        for (int i = 0; i <  trigger.length; i++) {
            Trigger trig = trigger[i];
            this.removeTrigger(ctxt, trig.getName(), trig.getGroup());
            found = true;
        }
        synchronized (jobLock) {
            found = (jobsByFQN.remove(key) != null) | found;
            if (found) {
                HashMap grpMap = (HashMap) jobsByGroup.get(groupName);
                if (grpMap != null) {
                    grpMap.remove(jobName);
                    if (grpMap.size() == 0) {
                        jobsByGroup.remove(groupName);
                    }
                }
            }
        }
        return found;
}

Remove (delete) the org.quartz.Job with the given name, and any org.quartz.Trigger s that reference it.

 public boolean removeTrigger(SchedulingContext ctxt,
    String triggerName,
    String groupName) 
{
        String key = TriggerWrapper.getTriggerNameKey(triggerName, groupName);
        boolean found = false;
        synchronized (triggerLock) {
            // remove from triggers by FQN map
            found = (triggersByFQN.remove(key) == null) ? false : true;
            if (found) {
                TriggerWrapper tw = null;
                // remove from triggers by group
                HashMap grpMap = (HashMap) triggersByGroup.get(groupName);
                if (grpMap != null) {
                    grpMap.remove(triggerName);
                    if (grpMap.size() == 0) {
                        triggersByGroup.remove(groupName);
                    }
                }
                // remove from triggers array
                Iterator tgs = triggers.iterator();
                while (tgs.hasNext()) {
                    tw = (TriggerWrapper) tgs.next();
                    if (key.equals(tw.key)) {
                        tgs.remove();
                        break;
                    }
                }
                timeTriggers.remove(tw);
                JobWrapper jw = (JobWrapper) jobsByFQN.get(JobWrapper
                        .getJobNameKey(tw.trigger.getJobName(), tw.trigger
                                .getJobGroup()));
                Trigger[] trigs = getTriggersForJob(ctxt, tw.trigger
                        .getJobName(), tw.trigger.getJobGroup());
                if ((trigs == null || trigs.length == 0) && !jw.jobDetail.isDurable()) {
                    removeJob(ctxt, tw.trigger.getJobName(), tw.trigger
                            .getJobGroup());
                }
            }
        }
        return found;
}

Remove (delete) the org.quartz.Trigger with the given name.

 public boolean replaceTrigger(SchedulingContext ctxt,
    String triggerName,
    String groupName,
    Trigger newTrigger) throws JobPersistenceException 
{
        String key = TriggerWrapper.getTriggerNameKey(triggerName, groupName);
        boolean found = false;
        synchronized (triggerLock) {
            // remove from triggers by FQN map
            TriggerWrapper tw = (TriggerWrapper) triggersByFQN.remove(key);
            found = ( tw == null) ? false : true;
            if (found) {
                if (!tw.getTrigger().getJobName().equals(newTrigger.getJobName()) ||
                    !tw.getTrigger().getJobGroup().equals(newTrigger.getJobGroup())) {
                    throw new JobPersistenceException("New trigger is not related to the same job as the old trigger.");
                }
                tw = null;
                // remove from triggers by group
                HashMap grpMap = (HashMap) triggersByGroup.get(groupName);
                if (grpMap != null) {
                    grpMap.remove(triggerName);
                    if (grpMap.size() == 0) {
                        triggersByGroup.remove(groupName);
                    }
                }
                // remove from triggers array
                Iterator tgs = triggers.iterator();
                while (tgs.hasNext()) {
                    tw = (TriggerWrapper) tgs.next();
                    if (key.equals(tw.key)) {
                        tgs.remove();
                        break;
                    }
                }
                timeTriggers.remove(tw);
                try {
                    storeTrigger(ctxt, newTrigger, false);
                } catch(JobPersistenceException jpe) {
                    storeTrigger(ctxt, tw.getTrigger(), false); // put previous trigger back...
                    throw jpe;
                }
            }
        }
        return found;
}

 public  void resumeAll(SchedulingContext ctxt) 
{
        synchronized (pausedTriggerGroups) {
            String[] names = getTriggerGroupNames(ctxt);
            for (int i = 0; i <  names.length; i++) {
                resumeTriggerGroup(ctxt, names[i]);
            }
        }
}

Resume (un-pause) all triggers - equivalent of calling resumeTriggerGroup(group) on every group.

If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.

 public  void resumeJob(SchedulingContext ctxt,
    String jobName,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            Trigger[] triggers = getTriggersForJob(ctxt, jobName, groupName);
            for (int j = 0; j <  triggers.length; j++) {
                resumeTrigger(ctxt, triggers[j].getName(), triggers[j].getGroup());
            }
        }
}

Resume (un-pause) the org.quartz.JobDetail with the given name.

If any of the Job'sTrigger s missed one or more fire-times, then the Trigger's misfire instruction will be applied.

 public  void resumeJobGroup(SchedulingContext ctxt,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            String[] jobNames = getJobNames(ctxt, groupName);
            for (int i = 0; i <  jobNames.length; i++) {
                Trigger[] triggers = getTriggersForJob(ctxt, jobNames[i],
                        groupName);
                for (int j = 0; j <  triggers.length; j++) {
                    resumeTrigger(ctxt, triggers[j].getName(),
                            triggers[j].getGroup());
                }
            }
        }
}

Resume (un-pause) all of the org.quartz.JobDetail s in the given group.

If any of the Job s had Trigger s that missed one or more fire-times, then the Trigger's misfire instruction will be applied.

 public  void resumeTrigger(SchedulingContext ctxt,
    String triggerName,
    String groupName) 
{
        TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                .getTriggerNameKey(triggerName, groupName));
        Trigger trig = tw.getTrigger();
        // does the trigger exist?
        if (tw == null || tw.trigger == null) {
            return;
        }
        // if the trigger is not paused resuming it does not make sense...
        if (tw.state != TriggerWrapper.STATE_PAUSED &&
                tw.state != TriggerWrapper.STATE_PAUSED_BLOCKED) {
            return;
        }
        synchronized (triggerLock) {
            if(blockedJobs.contains( JobWrapper.getJobNameKey(trig.getJobName(), trig.getJobGroup()) )) {
                tw.state = TriggerWrapper.STATE_BLOCKED;
            } else {
                tw.state = TriggerWrapper.STATE_WAITING;
            }
            applyMisfire(tw);
            if (tw.state == TriggerWrapper.STATE_WAITING) {
                timeTriggers.add(tw);
            }
        }
}

Resume (un-pause) the Trigger with the given name.

If the Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.

 public  void resumeTriggerGroup(SchedulingContext ctxt,
    String groupName) 
{
        synchronized (pausedTriggerGroups) {
            String[] names = getTriggerNames(ctxt, groupName);
            for (int i = 0; i <  names.length; i++) {
                resumeTrigger(ctxt, names[i], groupName);
            }
            pausedTriggerGroups.remove(groupName);
        }
}

Resume (un-pause) all of the Trigger s in the given group.

If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.

 public Calendar retrieveCalendar(SchedulingContext ctxt,
    String calName) 
{
        return (Calendar) calendarsByName.get(calName);
}

Retrieve the given org.quartz.Trigger .

 public JobDetail retrieveJob(SchedulingContext ctxt,
    String jobName,
    String groupName) 
{
        JobWrapper jw = (JobWrapper) jobsByFQN.get(JobWrapper.getJobNameKey(
                jobName, groupName));
        return (jw != null) ? (JobDetail)jw.jobDetail.clone() : null;
}

Retrieve the org.quartz.JobDetail for the given org.quartz.Job .

 public Trigger retrieveTrigger(SchedulingContext ctxt,
    String triggerName,
    String groupName) 
{
        TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                .getTriggerNameKey(triggerName, groupName));
        return (tw != null) ? (Trigger)tw.getTrigger().clone() : null;
}

Retrieve the given org.quartz.Trigger .

 public  void schedulerStarted() throws SchedulerException 
{
        // nothing to do
}

 protected  void setAllTriggersOfJobToState(String jobName,
    String jobGroup,
    int state) 
{
        ArrayList tws = getTriggerWrappersForJob(jobName, jobGroup);
        Iterator itr = tws.iterator();
        while (itr.hasNext()) {
            TriggerWrapper tw = (TriggerWrapper) itr.next();
            tw.state = state;
            if(state != TriggerWrapper.STATE_WAITING) {
                timeTriggers.remove(tw);
            }
        }
}

 public  void setMisfireThreshold(long misfireThreshold) 
{
        if (misfireThreshold <  1) {
            throw new IllegalArgumentException("Misfirethreashold must be larger than 0");
        }
        this.misfireThreshold = misfireThreshold;
}

The number of milliseconds by which a trigger must have missed its next-fire-time, in order for it to be considered "misfired" and thus have its misfire instruction applied.

 public  void shutdown() 
{

}

Called by the QuartzScheduler to inform the JobStore that it should free up all of it's resources because the scheduler is shutting down.

 public  void storeCalendar(SchedulingContext ctxt,
    String name,
    Calendar calendar,
    boolean replaceExisting,
    boolean updateTriggers) throws ObjectAlreadyExistsException 
{
        Object obj = calendarsByName.get(name);
        if (obj != null && replaceExisting == false) {
            throw new ObjectAlreadyExistsException(
                "Calendar with name '" + name + "' already exists.");
        } else if (obj != null) {
            calendarsByName.remove(name);
        }
        calendarsByName.put(name, calendar);
        if(obj != null && updateTriggers) {
            synchronized (triggerLock) {
                Iterator trigs = getTriggerWrappersForCalendar(name).iterator();
                while (trigs.hasNext()) {
                    TriggerWrapper tw = (TriggerWrapper) trigs.next();
                    Trigger trig = tw.getTrigger();
                    boolean removed = timeTriggers.remove(tw);
                    trig.updateWithNewCalendar(calendar, getMisfireThreshold());
                    if(removed) {
                        timeTriggers.add(tw);
                    }
                }
            }
        }
}

Store the given org.quartz.Calendar .

 public  void storeJob(SchedulingContext ctxt,
    JobDetail newJob,
    boolean replaceExisting) throws ObjectAlreadyExistsException 
{
        JobWrapper jw = new JobWrapper((JobDetail)newJob.clone());
        boolean repl = false;
        if (jobsByFQN.get(jw.key) != null) {
            if (!replaceExisting) {
                throw new ObjectAlreadyExistsException(newJob);
            }
            repl = true;
        }
        synchronized (jobLock) {
            if (!repl) {
                // get job group
                HashMap grpMap = (HashMap) jobsByGroup.get(newJob.getGroup());
                if (grpMap == null) {
                    grpMap = new HashMap(100);
                    jobsByGroup.put(newJob.getGroup(), grpMap);
                }
                // add to jobs by group
                grpMap.put(newJob.getName(), jw);
                // add to jobs by FQN map
                jobsByFQN.put(jw.key, jw);
            } else {
                // update job detail
                JobWrapper orig = (JobWrapper) jobsByFQN.get(jw.key);
                orig.jobDetail = jw.jobDetail; // already cloned
            }
        }
}

Store the given org.quartz.Job .

 public  void storeJobAndTrigger(SchedulingContext ctxt,
    JobDetail newJob,
    Trigger newTrigger) throws JobPersistenceException 
{
        storeJob(ctxt, newJob, false);
        storeTrigger(ctxt, newTrigger, false);
}

Store the given org.quartz.JobDetail and org.quartz.Trigger .

 public  void storeTrigger(SchedulingContext ctxt,
    Trigger newTrigger,
    boolean replaceExisting) throws JobPersistenceException 
{
        TriggerWrapper tw = new TriggerWrapper((Trigger)newTrigger.clone());
        if (triggersByFQN.get(tw.key) != null) {
            if (!replaceExisting) {
                throw new ObjectAlreadyExistsException(newTrigger);
            }
            removeTrigger(ctxt, newTrigger.getName(), newTrigger.getGroup());
        }
        if (retrieveJob(ctxt, newTrigger.getJobName(), newTrigger.getJobGroup()) == null) {
            throw new JobPersistenceException("The job ("
                    + newTrigger.getFullJobName()
                    + ") referenced by the trigger does not exist.");
        }
        synchronized (triggerLock) {
            // add to triggers array
            triggers.add(tw);
            // add to triggers by group
            HashMap grpMap = (HashMap) triggersByGroup.get(newTrigger
                    .getGroup());
            if (grpMap == null) {
                grpMap = new HashMap(100);
                triggersByGroup.put(newTrigger.getGroup(), grpMap);
            }
            grpMap.put(newTrigger.getName(), tw);
            // add to triggers by FQN map
            triggersByFQN.put(tw.key, tw);
            synchronized (pausedTriggerGroups) {
                if (pausedTriggerGroups.contains(newTrigger.getGroup())) {
                    tw.state = TriggerWrapper.STATE_PAUSED;
                    if (blockedJobs.contains(tw.jobKey)) {
                        tw.state = TriggerWrapper.STATE_PAUSED_BLOCKED;
                    }
                } else if (blockedJobs.contains(tw.jobKey)) {
                    tw.state = TriggerWrapper.STATE_BLOCKED;
                } else {
                    timeTriggers.add(tw);
                }
            }
        }
}

Store the given org.quartz.Trigger .

 public boolean supportsPersistence() 
{
        return false;
}

 public TriggerFiredBundle triggerFired(SchedulingContext ctxt,
    Trigger trigger) 
{
        synchronized (triggerLock) {
            TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                    .getTriggerNameKey(trigger));
            // was the trigger deleted since being acquired?
            if (tw == null || tw.trigger == null) {
                return null;
            }
            // was the trigger completed since being acquired?
            if (tw.state == TriggerWrapper.STATE_COMPLETE) {
                return null;
            }
            // was the trigger paused since being acquired?
            if (tw.state == TriggerWrapper.STATE_PAUSED) {
                return null;
            }
            // was the trigger blocked since being acquired?
            if (tw.state == TriggerWrapper.STATE_BLOCKED) {
                return null;
            }
            // was the trigger paused and blocked since being acquired?
            if (tw.state == TriggerWrapper.STATE_PAUSED_BLOCKED) {
                return null;
            }
            Calendar cal = null;
            if (tw.trigger.getCalendarName() != null) {
                cal = retrieveCalendar(ctxt, tw.trigger.getCalendarName());
            }
            Date prevFireTime = trigger.getPreviousFireTime();
            // call triggered on our copy, and the scheduler's copy
            tw.trigger.triggered(cal);
            trigger.triggered(cal);
            //tw.state = TriggerWrapper.STATE_EXECUTING;
            tw.state = TriggerWrapper.STATE_WAITING;
            TriggerFiredBundle bndle = new TriggerFiredBundle(retrieveJob(ctxt,
                    trigger.getJobName(), trigger.getJobGroup()), trigger, cal,
                    false, new Date(), trigger.getPreviousFireTime(), prevFireTime,
                    trigger.getNextFireTime());
            JobDetail job = bndle.getJobDetail();
            if (job.isStateful()) {
                ArrayList trigs = getTriggerWrappersForJob(job.getName(), job
                        .getGroup());
                Iterator itr = trigs.iterator();
                while (itr.hasNext()) {
                    TriggerWrapper ttw = (TriggerWrapper) itr.next();
                    if(ttw.state == TriggerWrapper.STATE_WAITING) {
                        ttw.state = TriggerWrapper.STATE_BLOCKED;
                    }
                    if(ttw.state == TriggerWrapper.STATE_PAUSED) {
                        ttw.state = TriggerWrapper.STATE_PAUSED_BLOCKED;
                    }
                    timeTriggers.remove(ttw);
                }
                blockedJobs.add(JobWrapper.getJobNameKey(job));
            } else if (tw.trigger.getNextFireTime() != null) {
                synchronized (triggerLock) {
                    timeTriggers.add(tw);
                }
            }
            return bndle;
        }
}

Inform the JobStore that the scheduler is now firing the given Trigger (executing its associated Job), that it had previously acquired (reserved).

 public  void triggeredJobComplete(SchedulingContext ctxt,
    Trigger trigger,
    JobDetail jobDetail,
    int triggerInstCode) 
{
        synchronized (triggerLock) {
            String jobKey = JobWrapper.getJobNameKey(jobDetail.getName(), jobDetail
                    .getGroup());
            JobWrapper jw = (JobWrapper) jobsByFQN.get(jobKey);
            TriggerWrapper tw = (TriggerWrapper) triggersByFQN.get(TriggerWrapper
                    .getTriggerNameKey(trigger));
            // It's possible that the job is null if:
            //   1- it was deleted during execution
            //   2- RAMJobStore is being used only for volatile jobs / triggers
            //      from the JDBC job store
            if (jw != null) {
                JobDetail jd = jw.jobDetail;
                if (jd.isStateful()) {
                    JobDataMap newData = jobDetail.getJobDataMap();
                    if (newData != null) {
                        newData = (JobDataMap)newData.clone();
                        newData.clearDirtyFlag();
                    }
                    jd.setJobDataMap(newData);
                    blockedJobs.remove(JobWrapper.getJobNameKey(jd));
                    ArrayList trigs = getTriggerWrappersForJob(jd.getName(), jd
                            .getGroup());
                    Iterator itr = trigs.iterator();
                    while (itr.hasNext()) {
                        TriggerWrapper ttw = (TriggerWrapper) itr.next();
                        if (ttw.state == TriggerWrapper.STATE_BLOCKED) {
                            ttw.state = TriggerWrapper.STATE_WAITING;
                            timeTriggers.add(ttw);
                        }
                        if (ttw.state == TriggerWrapper.STATE_PAUSED_BLOCKED) {
                            ttw.state = TriggerWrapper.STATE_PAUSED;
                        }
                    }
                }
            } else { // even if it was deleted, there may be cleanup to do
                blockedJobs.remove(JobWrapper.getJobNameKey(jobDetail));
            }
            // check for trigger deleted during execution...
            if (tw != null) {
                if (triggerInstCode == Trigger.INSTRUCTION_DELETE_TRIGGER) {
                    if(trigger.getNextFireTime() == null) {
                        // double check for possible reschedule within job 
                        // execution, which would cancel the need to delete...
                        if(tw.getTrigger().getNextFireTime() == null) {
                            removeTrigger(ctxt, trigger.getName(), trigger.getGroup());
                        }
                    } else {
                        removeTrigger(ctxt, trigger.getName(), trigger.getGroup());
                    }
                } else if (triggerInstCode == Trigger.INSTRUCTION_SET_TRIGGER_COMPLETE) {
                    tw.state = TriggerWrapper.STATE_COMPLETE;
                    timeTriggers.remove(tw);
                } else if(triggerInstCode == Trigger.INSTRUCTION_SET_TRIGGER_ERROR) {
                    getLog().info("Trigger " + trigger.getFullName() + " set to ERROR state.");
                    tw.state = TriggerWrapper.STATE_ERROR;
                } else if (triggerInstCode == Trigger.INSTRUCTION_SET_ALL_JOB_TRIGGERS_ERROR) {
                    getLog().info("All triggers of Job " 
                            + trigger.getFullJobName() + " set to ERROR state.");
                    setAllTriggersOfJobToState(
                            trigger.getJobName(), 
                            trigger.getJobGroup(),
                            TriggerWrapper.STATE_ERROR);
                } else if (triggerInstCode == Trigger.INSTRUCTION_SET_ALL_JOB_TRIGGERS_COMPLETE) {
                    setAllTriggersOfJobToState(
                            trigger.getJobName(), 
                            trigger.getJobGroup(),
                            TriggerWrapper.STATE_COMPLETE);
                }
            }
        }
}

Inform the JobStore that the scheduler has completed the firing of the given Trigger (and the execution its associated Job), and that the org.quartz.JobDataMap in the given JobDetail should be updated if the Job is stateful.