@Override public InjectableStepsFactory buildStepsFactory(Configuration configuration) { InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration); if (stepsFactory != null) { return new CompositeStepsFactory(stepsFactory, factoryUsingSteps); } return factoryUsingSteps; } }
@Override protected <T, V extends T> T instanceOf(Class<T> type, Class<V> ofClass) { if (context != null) { try { return context.getInstanceOfType(type); } catch (Exception e) { // default to super class } } return super.instanceOf(type, ofClass); }
@Override protected ParameterConverters parameterConverters(AnnotationFinder annotationFinder, ResourceLoader resourceLoader, TableTransformers tableTransformers) { ParameterConverters converters = super.parameterConverters(annotationFinder, resourceLoader, tableTransformers); if (injector != null) { return converters.addConverters(findConverters(injector)); } return converters; }
@SuppressWarnings("unchecked") @Override public Configuration buildConfiguration() throws AnnotationRequired { if (annotationFinder().isAnnotationPresent(UsingGroovy.class)) { Class<GroovyClassLoader> classLoaderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class, Class.class, "classLoader"); Class<GroovyResourceFinder> resourceFinderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class, Class.class, "resourceFinder"); try { GroovyClassLoader classLoader = super.instanceOf(classLoaderClass, classLoaderClass); GroovyResourceFinder resourceFinder = super.instanceOf(resourceFinderClass, resourceFinderClass); context = createGroovyContext(classLoader, resourceFinder); } catch (Exception e) { annotationMonitor().elementCreationFailed(GroovyContext.class, e); } } else { annotationMonitor().annotationNotFound(UsingGroovy.class, annotatedClass()); } return super.buildConfiguration(); }
@Override public Configuration buildConfiguration() throws AnnotationRequired { AnnotationFinder finder = annotationFinder(); if (finder.isAnnotationPresent(UsingWeld.class)) { if (configuration == null) { return super.buildConfiguration(); } return configuration; } else { annotationMonitor().annotationNotFound(UsingWeld.class, annotatedClass()); } return super.buildConfiguration(); }
public Configuration buildConfiguration() throws AnnotationRequired { AnnotationFinder finder = annotationFinder(); if (finder.isAnnotationPresent(UsingPico.class)) { @SuppressWarnings("rawtypes") List<Class> moduleClasses = finder.getAnnotatedValues(UsingPico.class, Class.class, "modules"); List<PicoModule> modules = new ArrayList<>(); for (Class<PicoModule> moduleClass : moduleClasses) { try { modules.add(moduleClass.newInstance()); } catch (Exception e) { annotationMonitor().elementCreationFailed(moduleClass, e); } } if ( modules.size() > 0 ){ container = createPicoContainer(modules); } } else { annotationMonitor().annotationNotFound(UsingPico.class, annotatedClass()); } return super.buildConfiguration(); }
@Override public InjectableStepsFactory buildStepsFactory(Configuration configuration) { InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration); if (context != null) { return new CompositeStepsFactory(new GroovyStepsFactory(configuration, context), factoryUsingSteps); } return factoryUsingSteps; }
public Configuration buildConfiguration() throws AnnotationRequired { AnnotationFinder finder = annotationFinder(); if (finder.isAnnotationPresent(UsingGuice.class)) { @SuppressWarnings("rawtypes") List<Class> moduleClasses = finder.getAnnotatedValues(UsingGuice.class, Class.class, "modules"); List<Module> modules = new ArrayList<>(); for (Class<Module> moduleClass : moduleClasses) { try { modules.add(moduleClass.newInstance()); } catch (Exception e) { annotationMonitor().elementCreationFailed(moduleClass, e); } } // creating injector with any modules found if (modules.size() > 0) { injector = createInjector(modules); } } else { annotationMonitor().annotationNotFound(UsingGuice.class, annotatedClass()); } return super.buildConfiguration(); }
@Override protected <T, V extends T> T instanceOf(final Class<T> type, final Class<V> ofClass) { if (container != null) { T instance = null; try { instance = container.getComponent(type); } catch (AmbiguousComponentResolutionException e) { instance = container.getComponent(ofClass); } if ( instance != null ){ return instance; } } return super.instanceOf(type, ofClass); }
@Override protected ParameterConverters parameterConverters(AnnotationFinder annotationFinder, ResourceLoader resourceLoader, TableTransformers tableTransformers) { ParameterConverters converters = super.parameterConverters(annotationFinder, resourceLoader, tableTransformers); if (container != null) { return converters.addConverters(container.getComponents(ParameterConverter.class)); } return converters; }
@Override public InjectableStepsFactory buildStepsFactory(Configuration configuration) { InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration); if (container != null) { return new CompositeStepsFactory(new PicoStepsFactory(configuration, container), factoryUsingSteps); } return factoryUsingSteps; }
return super.instanceOf(type, ofClass);
@Override public InjectableStepsFactory buildStepsFactory(Configuration configuration) { InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration); if (injector != null) { return new CompositeStepsFactory(new GuiceStepsFactory(configuration, injector), factoryUsingSteps); } return factoryUsingSteps; }