Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 International Business Machines Corp.
   * 
   * See the NOTICE file distributed with this work for additional information
   * regarding copyright ownership. Licensed under the Apache License, 
   * Version 2.0 (the "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at
   * 
   *   http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.ibm.jbatch.container.artifact.proxy;
 
 import java.util.List;
 import java.util.Map;
 
 
 
 
 public class ListenerFactory {
 
     private List<ListenerInfojobLevelListenerInfo = null;
 
 
     /*
      * Build job-level ListenerInfo(s) up-front, but build step-level ones
      * lazily.
      */
     public ListenerFactory(JSLJob jobModelInjectionReferences injectionRefs) {
         initJobLevelListeners(jobModelinjectionRefs);
     }
 
     private void initJobLevelListeners(JSLJob jobModelInjectionReferences injectionRefs) {
          = new ArrayList<ListenerInfo>();
 
         Listeners jobLevelListeners = jobModel.getListeners();
 
         if (jobLevelListeners != null) {
             for (Listener listener : jobLevelListeners.getListenerList()) {
                 ListenerInfo info = buildListenerInfo(listenerinjectionRefs);
                 .add(info);
             }
         }
     }
 
     /*
      * Does NOT throw an exception if a step-level listener is annotated with
      * 
      * @JobListener, even if that is the only type of listener annotation found.
      */
     private synchronized List<ListenerInfogetStepListenerInfo(Step stepInjectionReferences injectionRefs) {
         if (!.containsKey(step.getId())) {
             List<ListenerInfostepListenerInfoList = new ArrayList<ListenerInfo>();
             .put(step.getId(), stepListenerInfoList);
 
             Listeners stepLevelListeners = step.getListeners();
             if (stepLevelListeners != null) {
                 for (Listener listener : stepLevelListeners.getListenerList()) {
                     ListenerInfo info = buildListenerInfo(listenerinjectionRefs);
                     stepListenerInfoList.add(info);
                 }
             }
 
             return stepListenerInfoList;
         } else {
             return .get(step.getId());
         }
     }
 
     private ListenerInfo buildListenerInfo(Listener listenerInjectionReferences injectionRefs) {
 
         String id = listener.getRef();
 
        List<PropertypropList = (listener.getProperties() == null) ? null : listener.getProperties().getPropertyList();
        injectionRefs.setProps(propList);
        Object listenerArtifact = ProxyFactory.loadArtifact(idinjectionRefs);
        if (listenerArtifact == null) {
            throw new IllegalArgumentException("Load of artifact id: " + id + " returned <null>.");
        }
        ListenerInfo info = new ListenerInfo(listenerArtifactpropList);
        return info;
    }
        List<JobListenerProxyretVal = new ArrayList<JobListenerProxy>();
        for (ListenerInfo li : ) {
            if (li.isJobListener()) {
                JobListenerProxy proxy = new JobListenerProxy((JobListenerli.getArtifact());
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<ChunkListenerProxygetChunkListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<ChunkListenerProxyretVal = new ArrayList<ChunkListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isChunkListener()) {
                ChunkListenerProxy proxy = new ChunkListenerProxy((ChunkListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<ItemProcessListenerProxygetItemProcessListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isItemProcessListener()) {
                ItemProcessListenerProxy proxy = new ItemProcessListenerProxy((ItemProcessListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<ItemReadListenerProxygetItemReadListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<ItemReadListenerProxyretVal = new ArrayList<ItemReadListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isItemReadListener()) {
                ItemReadListenerProxy proxy = new ItemReadListenerProxy((ItemReadListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<ItemWriteListenerProxygetItemWriteListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<ItemWriteListenerProxyretVal = new ArrayList<ItemWriteListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isItemWriteListener()) {
                ItemWriteListenerProxy proxy = new ItemWriteListenerProxy((ItemWriteListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<RetryProcessListenerProxygetRetryProcessListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isRetryProcessListener()) {
                RetryProcessListenerProxy proxy = new RetryProcessListenerProxy((RetryProcessListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    
    public List<RetryReadListenerProxygetRetryReadListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<RetryReadListenerProxyretVal = new ArrayList<RetryReadListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isRetryReadListener()) {
                RetryReadListenerProxy proxy = new RetryReadListenerProxy((RetryReadListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    
    public List<RetryWriteListenerProxygetRetryWriteListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isRetryWriteListener()) {
                RetryWriteListenerProxy proxy = new RetryWriteListenerProxy((RetryWriteListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    
    public List<SkipProcessListenerProxygetSkipProcessListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isSkipProcessListener()) {
                SkipProcessListenerProxy proxy = new SkipProcessListenerProxy((SkipProcessListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<SkipReadListenerProxygetSkipReadListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<SkipReadListenerProxyretVal = new ArrayList<SkipReadListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isSkipReadListener()) {
                SkipReadListenerProxy proxy = new SkipReadListenerProxy((SkipReadListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    
    public List<SkipWriteListenerProxygetSkipWriteListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<SkipWriteListenerProxyretVal = new ArrayList<SkipWriteListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isSkipWriteListener()) {
                SkipWriteListenerProxy proxy = new SkipWriteListenerProxy((SkipWriteListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    public List<StepListenerProxygetStepListeners(Step stepInjectionReferences injectionRefsStepContextImpl stepContext) {
        List<ListenerInfostepListenerInfo = getStepListenerInfo(stepinjectionRefs);
        List<StepListenerProxyretVal = new ArrayList<StepListenerProxy>();
        for (ListenerInfo li : stepListenerInfo) {
            if (li.isStepListener()) {
                StepListenerProxy proxy = new StepListenerProxy((StepListenerli.getArtifact());
                proxy.setStepContext(stepContext);
                retVal.add(proxy);
            }
        }
        return retVal;
    }
    private class ListenerInfo {
        Object listenerArtifact = null;
        Class listenerArtifactClass = null;
        List<PropertypropList = null;
        Object getArtifact() {
            return ;
        }
        private ListenerInfo(Object listenerArtifactList<PropertypropList) {
            this. = listenerArtifact;
            this. = listenerArtifact.getClass();
            this. = propList;
        }
        boolean isJobListener() {
            return JobListener.class.isAssignableFrom();
        }
        boolean isStepListener() {
            return StepListener.class.isAssignableFrom();
        }
        boolean isChunkListener() {
            return ChunkListener.class.isAssignableFrom();
        }
        boolean isItemProcessListener() {
            return ItemProcessListener.class.isAssignableFrom();
        }
        boolean isItemReadListener() {
            return ItemReadListener.class.isAssignableFrom();
        }
        boolean isItemWriteListener() {
            return ItemWriteListener.class.isAssignableFrom();
        }
        boolean isRetryReadListener() {
            return RetryReadListener.class.isAssignableFrom();
        }
        
        boolean isRetryWriteListener() {
            return RetryWriteListener.class.isAssignableFrom();
        }
        
        boolean isRetryProcessListener() {
            return RetryProcessListener.class.isAssignableFrom();
        }
        boolean isSkipProcessListener() {
            return SkipProcessListener.class.isAssignableFrom();
        }
        
        boolean isSkipReadListener() {
            return SkipReadListener.class.isAssignableFrom();
        }
        
        boolean isSkipWriteListener() {
            return SkipWriteListener.class.isAssignableFrom();
        }
        List<PropertygetPropList() {
            return ;
        }
        void setPropList(List<PropertypropList) {
            this. = propList;
        }
    }
New to GrepCode? Check out our FAQ X