org.quartz.Matcher Java Examples

public void addJobListener(JobListener jobListener, Matcher<JobKey> matcher) {
    if (jobListener.getName() == null || jobListener.getName().length() == 0) {
        throw new IllegalArgumentException(
                "JobListener name cannot be empty.");
    }
    
    synchronized (globalJobListeners) {
        globalJobListeners.put(jobListener.getName(), jobListener);
        LinkedList<Matcher<JobKey>> matchersL = new  LinkedList<Matcher<JobKey>>();
        if(matcher != null)
            matchersL.add(matcher);
        else
            matchersL.add(EverythingMatcher.allJobs());
        
        globalJobListenersMatchers.put(jobListener.getName(), matchersL);
    }
}
 

@Override
public void addGlobalJobListener(JobListener jobGlobalListener) throws SchedulerException {
	final Scheduler defaultScheduler;
	final List<Matcher<JobKey>> allJobs = new ArrayList<Matcher<JobKey>>();
	allJobs.add(EverythingMatcher.allJobs());
	if (Parameter.QUARTZ_DEFAULT_LISTENER_DISABLED.getValueAsBoolean()) {
		defaultScheduler = null;
		LOG.debug("Initialization of Quartz default listener has been disabled");
	} else {
		defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
		defaultScheduler.getListenerManager().addJobListener(jobGlobalListener, allJobs);
	}
	for (final Scheduler scheduler : JobInformations.getAllSchedulers()) {
		if (scheduler != defaultScheduler) {
			scheduler.getListenerManager().addJobListener(jobGlobalListener, allJobs);
		}
	}
}
 

public void addTriggerListener(TriggerListener triggerListener, Matcher<TriggerKey> matcher) {
    if(matcher == null)
        throw new IllegalArgumentException("Null value not acceptable for matcher.");
    
    if (triggerListener.getName() == null
            || triggerListener.getName().length() == 0) {
        throw new IllegalArgumentException(
                "TriggerListener name cannot be empty.");
    }

    synchronized (globalTriggerListeners) {
        globalTriggerListeners.put(triggerListener.getName(), triggerListener);
        List<Matcher<TriggerKey>> matchers = new LinkedList<Matcher<TriggerKey>>();
        matchers.add(matcher);
        globalTriggerListenersMatchers.put(triggerListener.getName(), matchers);
    }
}
 

public void addTriggerListener(TriggerListener triggerListener, List<Matcher<TriggerKey>> matchers) {
    if (triggerListener.getName() == null
            || triggerListener.getName().length() == 0) {
        throw new IllegalArgumentException(
                "TriggerListener name cannot be empty.");
    }

    synchronized (globalTriggerListeners) {
        globalTriggerListeners.put(triggerListener.getName(), triggerListener);

        LinkedList<Matcher<TriggerKey>> matchersL = new  LinkedList<Matcher<TriggerKey>>();
        if(matchers != null && matchers.size() > 0)
            matchersL.addAll(matchers);
        else
            matchersL.add(EverythingMatcher.allTriggers());

        globalTriggerListenersMatchers.put(triggerListener.getName(), matchersL);
    }
}
 

public void addJobListener(JobListener jobListener, List<Matcher<JobKey>> matchers) {
    if (jobListener.getName() == null || jobListener.getName().length() == 0) {
        throw new IllegalArgumentException(
                "JobListener name cannot be empty.");
    }
    
    synchronized (globalJobListeners) {
        globalJobListeners.put(jobListener.getName(), jobListener);
        LinkedList<Matcher<JobKey>> matchersL = new  LinkedList<Matcher<JobKey>>();
        if(matchers != null && matchers.size() > 0)
            matchersL.addAll(matchers);
        else
            matchersL.add(EverythingMatcher.allJobs());
        
        globalJobListenersMatchers.put(jobListener.getName(), matchersL);
    }
}
 

public List<Matcher<JobKey>> getJobListenerMatchers(String listenerName) {
    synchronized (globalJobListeners) {
        List<Matcher<JobKey>> matchers = globalJobListenersMatchers.get(listenerName);
        if(matchers == null)
            return null;
        return Collections.unmodifiableList(matchers);
    }
}
 

protected AndMatcher(Matcher<T> leftOperand, Matcher<T> rightOperand) {
    if(leftOperand == null || rightOperand == null)
        throw new IllegalArgumentException("Two non-null operands required!");
    
    this.leftOperand = leftOperand;
    this.rightOperand = rightOperand;
}
 

private boolean matchTriggerListener(TriggerListener listener, TriggerKey key) {
    List<Matcher<TriggerKey>> matchers = getListenerManager().getTriggerListenerMatchers(listener.getName());
    if(matchers == null)
        return true;
    for(Matcher<TriggerKey> matcher: matchers) {
        if(matcher.isMatch(key))
            return true;
    }
    return false;
}
 

private boolean matchJobListener(JobListener listener, JobKey key) {
    List<Matcher<JobKey>> matchers = getListenerManager().getJobListenerMatchers(listener.getName());
    if(matchers == null)
        return true;
    for(Matcher<JobKey> matcher: matchers) {
        if(matcher.isMatch(key))
            return true;
    }
    return false;
}
 

public boolean setTriggerListenerMatchers(String listenerName, List<Matcher<TriggerKey>> matchers)  {
    if(matchers == null)
        throw new IllegalArgumentException("Non-null value not acceptable.");
    
    synchronized (globalTriggerListeners) {
        List<Matcher<TriggerKey>> oldMatchers = globalTriggerListenersMatchers.get(listenerName);
        if(oldMatchers == null)
            return false;
        globalTriggerListenersMatchers.put(listenerName, matchers);
        return true;
    }
}
 

public List<Matcher<TriggerKey>> getTriggerListenerMatchers(String listenerName) {
    synchronized (globalTriggerListeners) {
        List<Matcher<TriggerKey>> matchers = globalTriggerListenersMatchers.get(listenerName);
        if(matchers == null)
            return null;
        return Collections.unmodifiableList(matchers);
    }
}
 

public boolean removeTriggerListenerMatcher(String listenerName, Matcher<TriggerKey> matcher) {
    if(matcher == null)
        throw new IllegalArgumentException("Non-null value not acceptable.");
    
    synchronized (globalTriggerListeners) {
        List<Matcher<TriggerKey>> matchers = globalTriggerListenersMatchers.get(listenerName);
        if(matchers == null)
            return false;
        return matchers.remove(matcher);
    }
}
 

public boolean addTriggerListenerMatcher(String listenerName, Matcher<TriggerKey> matcher) {
    if(matcher == null)
        throw new IllegalArgumentException("Non-null value not acceptable.");
    
    synchronized (globalTriggerListeners) {
        List<Matcher<TriggerKey>> matchers = globalTriggerListenersMatchers.get(listenerName);
        if(matchers == null)
            return false;
        matchers.add(matcher);
        return true;
    }
}
 

public boolean setJobListenerMatchers(String listenerName, List<Matcher<JobKey>> matchers)  {
    if(matchers == null)
        throw new IllegalArgumentException("Non-null value not acceptable.");
    
    synchronized (globalJobListeners) {
        List<Matcher<JobKey>> oldMatchers = globalJobListenersMatchers.get(listenerName);
        if(oldMatchers == null)
            return false;
        globalJobListenersMatchers.put(listenerName, matchers);
        return true;
    }
}
 

public boolean removeJobListenerMatcher(String listenerName, Matcher<JobKey> matcher) {
    if(matcher == null)
        throw new IllegalArgumentException("Non-null value not acceptable.");
    
    synchronized (globalJobListeners) {
        List<Matcher<JobKey>> matchers = globalJobListenersMatchers.get(listenerName);
        if(matchers == null)
            return false;
        return matchers.remove(matcher);
    }
}
 

public boolean addJobListenerMatcher(String listenerName, Matcher<JobKey> matcher) {
    if(matcher == null)
        throw new IllegalArgumentException("Null value not acceptable.");
    
    synchronized (globalJobListeners) {
        List<Matcher<JobKey>> matchers = globalJobListenersMatchers.get(listenerName);
        if(matchers == null)
            return false;
        matchers.add(matcher);
        return true;
    }
}
 

public AbstractQuartzTaskManager(TaskRepository taskRepository, TaskStore taskStore) throws TaskException {

        this.taskRepository = taskRepository;
        this.scheduler = TasksDSComponent.getScheduler();
        this.taskStore = taskStore;
        try {
            Matcher<TriggerKey> tenantTaskTypeGroupMatcher = GroupMatcher.groupEquals(this.getTenantTaskGroup());
            this.getScheduler().getListenerManager().addTriggerListener(
                    new TaskTriggerListener(this.getTenantTaskGroup()), tenantTaskTypeGroupMatcher);
        } catch (SchedulerException e) {
            throw new TaskException("Error in initiating task trigger listener", TaskException.Code.UNKNOWN, e);
        }
    }
 

protected OrMatcher(Matcher<T> leftOperand, Matcher<T> rightOperand) {
    if(leftOperand == null || rightOperand == null)
        throw new IllegalArgumentException("Two non-null operands required!");
    
    this.leftOperand = leftOperand;
    this.rightOperand = rightOperand;
}
 

protected NotMatcher(Matcher<T> operand) {
    if(operand == null)
        throw new IllegalArgumentException("Non-null operand required!");
    
    this.operand = operand;
}
 

public Matcher<T> getRightOperand() {
    return rightOperand;
}
 

public void addTriggerListener(TriggerListener triggerListener, Matcher<TriggerKey> ... matchers) {
    addTriggerListener(triggerListener, Arrays.asList(matchers));
}
 

public Matcher<T> getLeftOperand() {
    return leftOperand;
}
 

/**
 * Create an AndMatcher that depends upon the result of both of the given matchers.
 */
public static <U extends Key<?>> AndMatcher<U> and(Matcher<U> leftOperand, Matcher<U> rightOperand) {
    return new AndMatcher<U>(leftOperand, rightOperand);
}
 

public void addJobListener(JobListener jobListener, Matcher<JobKey> ... matchers) {
    addJobListener(jobListener, Arrays.asList(matchers));
}
 

public Matcher<T> getRightOperand() {
    return rightOperand;
}
 

public Matcher<T> getLeftOperand() {
    return leftOperand;
}
 

/**
 * Create an OrMatcher that depends upon the result of at least one of the given matchers.
 */
public static <U extends Key<?>> OrMatcher<U> or(Matcher<U> leftOperand, Matcher<U> rightOperand) {
    return new OrMatcher<U>(leftOperand, rightOperand);
}
 

public Matcher<T> getOperand() {
    return operand;
}
 

/**
 * Create a NotMatcher that reverses the result of the given matcher.
 */
public static <U extends Key<?>> NotMatcher<U> not(Matcher<U> operand) {
    return new NotMatcher<U>(operand);
}