io.logspace.jvm.agent.shaded.quartz.core.ListenerManagerImpl Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of logspace-jvm-agent Show documentation
The newest version!
package io.logspace.jvm.agent.shaded.quartz.core;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import io.logspace.jvm.agent.shaded.quartz.JobKey;
import io.logspace.jvm.agent.shaded.quartz.JobListener;
import io.logspace.jvm.agent.shaded.quartz.ListenerManager;
import io.logspace.jvm.agent.shaded.quartz.Matcher;
import io.logspace.jvm.agent.shaded.quartz.SchedulerListener;
import io.logspace.jvm.agent.shaded.quartz.TriggerKey;
import io.logspace.jvm.agent.shaded.quartz.TriggerListener;
import io.logspace.jvm.agent.shaded.quartz.impl.matchers.EverythingMatcher;

public class ListenerManagerImpl implements ListenerManager {

    private Map globalJobListeners = new LinkedHashMap(10);

    private Map globalTriggerListeners = new LinkedHashMap(10);

    private Map>> globalJobListenersMatchers = new LinkedHashMap>>(10);

    private Map>> globalTriggerListenersMatchers = new LinkedHashMap>>(10);

    private ArrayList schedulerListeners = new ArrayList(10);

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

    public void addJobListener(JobListener jobListener, List> 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> matchersL = new  LinkedList>();
            if(matchers != null && matchers.size() > 0)
                matchersL.addAll(matchers);
            else
                matchersL.add(EverythingMatcher.allJobs());
            
            globalJobListenersMatchers.put(jobListener.getName(), matchersL);
        }
    }


    public void addJobListener(JobListener jobListener) {
        addJobListener(jobListener, EverythingMatcher.allJobs());
    }
    
    public void addJobListener(JobListener jobListener, Matcher 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> matchersL = new  LinkedList>();
            if(matcher != null)
                matchersL.add(matcher);
            else
                matchersL.add(EverythingMatcher.allJobs());
            
            globalJobListenersMatchers.put(jobListener.getName(), matchersL);
        }
    }


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

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

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

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


    public boolean removeJobListener(String name) {
        synchronized (globalJobListeners) {
            return (globalJobListeners.remove(name) != null);
        }
    }
    
    public List getJobListeners() {
        synchronized (globalJobListeners) {
            return java.util.Collections.unmodifiableList(new LinkedList(globalJobListeners.values()));
        }
    }

    public JobListener getJobListener(String name) {
        synchronized (globalJobListeners) {
            return globalJobListeners.get(name);
        }
    }

    public void addTriggerListener(TriggerListener triggerListener, Matcher ... matchers) {
        addTriggerListener(triggerListener, Arrays.asList(matchers));
    }
    
    public void addTriggerListener(TriggerListener triggerListener, List> 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> matchersL = new  LinkedList>();
            if(matchers != null && matchers.size() > 0)
                matchersL.addAll(matchers);
            else
                matchersL.add(EverythingMatcher.allTriggers());

            globalTriggerListenersMatchers.put(triggerListener.getName(), matchersL);
        }
    }
    
    public void addTriggerListener(TriggerListener triggerListener) {
        addTriggerListener(triggerListener, EverythingMatcher.allTriggers());
    }

    public void addTriggerListener(TriggerListener triggerListener, Matcher 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> matchers = new LinkedList>();
            matchers.add(matcher);
            globalTriggerListenersMatchers.put(triggerListener.getName(), matchers);
        }
    }

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

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

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

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

    public boolean removeTriggerListener(String name) {
        synchronized (globalTriggerListeners) {
            return (globalTriggerListeners.remove(name) != null);
        }
    }
    

    public List getTriggerListeners() {
        synchronized (globalTriggerListeners) {
            return java.util.Collections.unmodifiableList(new LinkedList(globalTriggerListeners.values()));
        }
    }

    public TriggerListener getTriggerListener(String name) {
        synchronized (globalTriggerListeners) {
            return globalTriggerListeners.get(name);
        }
    }
    
    
    public void addSchedulerListener(SchedulerListener schedulerListener) {
        synchronized (schedulerListeners) {
            schedulerListeners.add(schedulerListener);
        }
    }

    public boolean removeSchedulerListener(SchedulerListener schedulerListener) {
        synchronized (schedulerListeners) {
            return schedulerListeners.remove(schedulerListener);
        }
    }

    public List getSchedulerListeners() {
        synchronized (schedulerListeners) {
            return java.util.Collections.unmodifiableList(new ArrayList(schedulerListeners));
        }
    }
}