@Override public <T> Method getPostConstructMethod(Class<T> clazz) throws MultiException { Collector collector = new Collector(); Method retVal = Utilities.findPostConstruct(clazz, locator, collector); collector.throwIfErrors(); return retVal; }
/** * Gets the post construct from the analyzer, checking output * * @param implClass The non-null implementation class * @param analyzer The non-null analyzer * @param collector The non-null error collector * @return The possibly null post-construct method (check the collector for errors) */ public static Method getPostConstruct(Class<?> implClass, ClassAnalyzer analyzer, Collector collector) { try { return analyzer.getPostConstructMethod(implClass); } catch (MultiException me) { collector.addMultiException(me); return null; } catch (Throwable th) { collector.addThrowable(th); return null; } }
collector.addThrowable(e); return; this.notifyAll(); if (!collector.hasErrors()) { reified = true; collector.addThrowable(new IllegalArgumentException("Errors were discovered while reifying " + this));
private Map<SystemInjecteeImpl, Object> resolveAllDependencies(final ServiceHandle<?> root) throws MultiException, IllegalStateException { Collector errorCollector = new Collector(); final Map<SystemInjecteeImpl, Object> retVal = new LinkedHashMap<SystemInjecteeImpl, Object>(); for (SystemInjecteeImpl injectee : myConstructor.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } for (ResolutionInfo fieldRI : myFields) { for (SystemInjecteeImpl injectee : fieldRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } for (ResolutionInfo methodRI : myInitializers) { for (SystemInjecteeImpl injectee : methodRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } if (errorCollector.hasErrors()) { errorCollector.addThrowable(new IllegalArgumentException("While attempting to resolve the dependencies of " + implClass.getName() + " errors were found")); errorCollector.throwIfErrors(); } return retVal; }
/** * Calls the list of error services for the list of errors * * @param results the results * @param callThese the services to call */ public static void handleErrors(NarrowResults results, LinkedList<ErrorService> callThese) { Collector collector = new Collector(); for (ErrorResults errorResult : results.getErrors()) { for (ErrorService eService : callThese) { try { eService.onFailure(new ErrorInformationImpl( ErrorType.FAILURE_TO_REIFY, errorResult.getDescriptor(), errorResult.getInjectee(), errorResult.getMe())); } catch (MultiException me) { for (Throwable th : me.getErrors()) { collector.addThrowable(th); } } catch (Throwable th) { collector.addThrowable(th); } } } collector.throwIfErrors(); }
/* package */ ClassAnalyzer getAnalyzer(String name, Collector collector) { ClassAnalyzer retVal; synchronized (classAnalyzerLock) { if (name == null) { name = defaultClassAnalyzer ; } retVal = classAnalyzers.get(name); } if (retVal == null) { collector.addThrowable(new IllegalStateException( "Could not find an implementation of ClassAnalyzer with name " + name)); return null; } return retVal; }
private Map<SystemInjecteeImpl, Object> resolveAllDependencies(final ServiceHandle<?> root) throws MultiException, IllegalStateException { Collector errorCollector = new Collector(); final Map<SystemInjecteeImpl, Object> retVal = new LinkedHashMap<SystemInjecteeImpl, Object>(); for (SystemInjecteeImpl injectee : myConstructor.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } for (ResolutionInfo fieldRI : myFields) { for (SystemInjecteeImpl injectee : fieldRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } for (ResolutionInfo methodRI : myInitializers) { for (SystemInjecteeImpl injectee : methodRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } if (errorCollector.hasErrors()) { errorCollector.addThrowable(new IllegalArgumentException("While attempting to resolve the dependencies of " + implClass.getName() + " errors were found")); errorCollector.throwIfErrors(); } return retVal; }
/** * Calls the list of error services for the list of errors * * @param results the results * @param callThese the services to call */ public static void handleErrors(NarrowResults results, LinkedList<ErrorService> callThese) { Collector collector = new Collector(); for (ErrorResults errorResult : results.getErrors()) { for (ErrorService eService : callThese) { try { eService.onFailure(new ErrorInformationImpl( ErrorType.FAILURE_TO_REIFY, errorResult.getDescriptor(), errorResult.getInjectee(), errorResult.getMe())); } catch (MultiException me) { for (Throwable th : me.getErrors()) { collector.addThrowable(th); } } catch (Throwable th) { collector.addThrowable(th); } } } collector.throwIfErrors(); }
/* package */ ClassAnalyzer getAnalyzer(String name, Collector collector) { ClassAnalyzer retVal; synchronized (classAnalyzerLock) { if (name == null) { name = defaultClassAnalyzer ; } retVal = classAnalyzers.get(name); } if (retVal == null) { collector.addThrowable(new IllegalStateException( "Could not find an implementation of ClassAnalyzer with name " + name)); return null; } return retVal; }
@Override public <T> Set<Field> getFields(Class<T> clazz) throws MultiException { Collector collector = new Collector(); Set<Field> retVal = Utilities.findInitializerFields(clazz, locator, collector); collector.throwIfErrors(); return retVal; }
/** * Gets the preDestroy from the analyzer, checking output * * @param implClass The non-null implementation class * @param analyzer The non-null analyzer * @param collector The non-null error collector * @return The possibly null pre-destroy method (check the collector for errors) */ public static Method getPreDestroy(Class<?> implClass, ClassAnalyzer analyzer, Collector collector) { try { return analyzer.getPreDestroyMethod(implClass); } catch (MultiException me) { collector.addMultiException(me); return null; } catch (Throwable th) { collector.addThrowable(th); return null; } }
private Map<SystemInjecteeImpl, Object> resolveAllDependencies(final ServiceHandle<?> root) throws MultiException, IllegalStateException { Collector errorCollector = new Collector(); final Map<SystemInjecteeImpl, Object> retVal = new LinkedHashMap<SystemInjecteeImpl, Object>(); for (SystemInjecteeImpl injectee : myConstructor.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } for (ResolutionInfo fieldRI : myFields) { for (SystemInjecteeImpl injectee : fieldRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } for (ResolutionInfo methodRI : myInitializers) { for (SystemInjecteeImpl injectee : methodRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } if (errorCollector.hasErrors()) { errorCollector.addThrowable(new IllegalArgumentException("While attempting to resolve the dependencies of " + implClass.getName() + " errors were found")); errorCollector.throwIfErrors(); } return retVal; }
/** * Calls the list of error services for the list of errors * * @param results the results * @param callThese the services to call */ public static void handleErrors(NarrowResults results, LinkedList<ErrorService> callThese) { Collector collector = new Collector(); for (ErrorResults errorResult : results.getErrors()) { for (ErrorService eService : callThese) { try { eService.onFailure(new ErrorInformationImpl( ErrorType.FAILURE_TO_REIFY, errorResult.getDescriptor(), errorResult.getInjectee(), errorResult.getMe())); } catch (MultiException me) { for (Throwable th : me.getErrors()) { collector.addThrowable(th); } } catch (Throwable th) { collector.addThrowable(th); } } } collector.throwIfErrors(); }
/* package */ ClassAnalyzer getAnalyzer(String name, Collector collector) { ClassAnalyzer retVal; synchronized (classAnalyzerLock) { if (name == null) { name = defaultClassAnalyzer ; } retVal = classAnalyzers.get(name); } if (retVal == null) { collector.addThrowable(new IllegalStateException( "Could not find an implementation of ClassAnalyzer with name " + name)); return null; } return retVal; }
collector.addThrowable(e); return; this.notifyAll(); if (!collector.hasErrors()) { reified = true; collector.addThrowable(new IllegalArgumentException("Errors were discovered while reifying " + this));
@Override public <T> Method getPreDestroyMethod(Class<T> clazz) throws MultiException { Collector collector = new Collector(); Method retVal = Utilities.findPreDestroy(clazz, locator, collector); collector.throwIfErrors(); return retVal; }
/** * Gets the preDestroy from the analyzer, checking output * * @param implClass The non-null implementation class * @param analyzer The non-null analyzer * @param collector The non-null error collector * @return The possibly null pre-destroy method (check the collector for errors) */ public static Method getPreDestroy(Class<?> implClass, ClassAnalyzer analyzer, Collector collector) { try { return analyzer.getPreDestroyMethod(implClass); } catch (MultiException me) { collector.addMultiException(me); return null; } catch (Throwable th) { collector.addThrowable(th); return null; } }
private Map<SystemInjecteeImpl, Object> resolveAllDependencies(final ServiceHandle<?> root) throws MultiException, IllegalStateException { Collector errorCollector = new Collector(); final Map<SystemInjecteeImpl, Object> retVal = new LinkedHashMap<SystemInjecteeImpl, Object>(); for (SystemInjecteeImpl injectee : myConstructor.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } for (ResolutionInfo fieldRI : myFields) { for (SystemInjecteeImpl injectee : fieldRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } for (ResolutionInfo methodRI : myInitializers) { for (SystemInjecteeImpl injectee : methodRI.injectees) { InjectionResolver<?> resolver = locator.getInjectionResolverForInjectee(injectee); resolve(retVal, resolver, injectee, root, errorCollector); } } if (errorCollector.hasErrors()) { errorCollector.addThrowable(new IllegalArgumentException("While attempting to resolve the dependencies of " + implClass.getName() + " errors were found")); errorCollector.throwIfErrors(); } return retVal; }
/** * Calls the list of error services for the list of errors * * @param results the results * @param callThese the services to call */ public static void handleErrors(NarrowResults results, LinkedList<ErrorService> callThese) { Collector collector = new Collector(); for (ErrorResults errorResult : results.getErrors()) { for (ErrorService eService : callThese) { try { eService.onFailure(new ErrorInformationImpl( ErrorType.FAILURE_TO_REIFY, errorResult.getDescriptor(), errorResult.getInjectee(), errorResult.getMe())); } catch (MultiException me) { for (Throwable th : me.getErrors()) { collector.addThrowable(th); } } catch (Throwable th) { collector.addThrowable(th); } } } collector.throwIfErrors(); }
/* package */ ClassAnalyzer getAnalyzer(String name, Collector collector) { ClassAnalyzer retVal; synchronized (classAnalyzerLock) { if (name == null) { name = defaultClassAnalyzer ; } retVal = classAnalyzers.get(name); } if (retVal == null) { collector.addThrowable(new IllegalStateException( "Could not find an implementation of ClassAnalyzer with name " + name)); return null; } return retVal; }