public AdaptingInjection() { constructorInjection = new Jsr330ConstructorInjection(); methodInjection = new MethodInjection(); setterInjection = new SetterInjection(); annotatedMethodInjection = new AnnotatedMethodInjection(); annotatedFieldInjection = new AnnotatedFieldInjection(); }
/** * Throws an exception if the "resolved" parameter is null <em>unless</em> * {@link #useAllParameters} is set to false. * * @param member * @param i * @param expectedNameBinding * @param result */ @SuppressWarnings("synthetic-access") protected void nullCheck(final AccessibleObject member, final int i, final ParameterNameBinding expectedNameBinding, final Object result) { if (result == null && !isNullParamAllowed(member, i)) { throw new ParameterCannotBeNullException(i, member, expectedNameBinding.getName()); } }
@Override public T run(final Object inst) { final ParameterToAccessibleObjectPair[] matchingParameters = getMatchingParameterListForMembers(guardedContainer); return decorateComponentInstance(matchingParameters, currentMonitor(), inst, container, guardedContainer, into, superclassPortion); } };
@SuppressWarnings("unchecked") public MultiInjector(final Object key, final Class<T> impl, final ComponentMonitor monitor, final String setterPrefix, final boolean useNames, final boolean useAllParameter, final ConstructorParameters constructorParams, final FieldParameters[] fieldParams, final MethodParameters[] methodParams) { super(key, impl, monitor, useNames, monitor.newInjector(new ConstructorInjection.ConstructorInjector<T>(monitor, useNames, key, impl, constructorParams)), monitor.newInjector(new SetterInjection.SetterInjector<T>(key, impl, monitor, setterPrefix, useNames, "", false, methodParams)), monitor.newInjector(new AnnotatedMethodInjection.AnnotatedMethodInjector<T>(key, impl, methodParams, monitor, useNames, useAllParameter, Inject.class, getInjectionAnnotation("javax.inject.Inject"))), monitor.newInjector(new AnnotatedFieldInjection.AnnotatedFieldInjector<T>(key, impl, fieldParams, monitor, useNames, useAllParameter, Inject.class, getInjectionAnnotation("javax.inject.Inject"))) ); }
@Override public T run(final Object instance) { final ParameterToAccessibleObjectPair[] matchingParameters = getMatchingParameterListForMembers(guardedContainer); //Funky call where the instance we're decorating //happens to be null for static injection. return decorateComponentInstance(matchingParameters, currentMonitor(), null, container, guardedContainer, into, null); } };
public StaticInjection(final StaticsInitializedReferenceSet referenceSet, final ComponentAdapter<T> delegate, final boolean usenames, final boolean consumeAllParameters, final FieldParameters fieldParams[], final MethodParameters[] methodParams) { super(delegate); this.referenceSet = referenceSet; this.useNames = usenames; this.consumeAllParameters = consumeAllParameters; useNames = consumeAllParameters; this.fieldParams = fieldParams; this.methodParams = methodParams; wrappedInjectors = createListOfStaticInjectors(getComponentImplementation()); }
/** * Override to return lastFactory parameter to completely disable static injection. * @param lastFactory * @return */ protected ComponentFactory createStaticInjection(final ComponentFactory lastFactory) { return new AnnotatedStaticInjection(referenceSet).wrap(lastFactory); }
@Override public synchronized String getDescriptor() { if (injectionAnnotationNames == null) { injectionAnnotationNames = makeAnnotationNames(injectionAnnotations); } return "AnnotatedMethodInjector[" + injectionAnnotationNames + "]-"; }
private <T> InjectionType fieldAnnotatedInjectionAdapter(final Class<T> impl) { if (injectionFieldAnnotated(impl)) { return this.annotatedFieldInjection; } return null; }
/** * Checks to see if a null parameter is allowed in the given * constructor/field/method. The default version allows null * if the target object is not a primitive type. * @param member constructor method or field * @param i parameter #. * @return true if the null parameter might be allowed. */ protected boolean isNullParamAllowed(final AccessibleObject member, final int i) { return !(isPrimitiveArgument(member, i)); }
@Override protected <T> ConstructorInjector<T> newConstructorInjector(final ComponentMonitor monitor, final Object key, final Class<T> impl, final boolean useNames, final ConstructorParameters parameters) { return new ConstructorInjectorWithForcedPublicCtors<T>(rememberChosenConstructor, monitor, useNames, key, impl, parameters); }
private <T> InjectionType methodAnnotatedInjectionAdapter(final Class<T> impl) { if (injectionMethodAnnotated(impl)) { return annotatedMethodInjection; } return null; }
/** * Reinjecting into a method. * @param key the component-key from the parent set of components to inject into * @param implementation the implementation of the component that is going to result. * @param instance the object that has the provider method to be invoked * @param reinjectionType the InjectionFactory to use for reinjection. * @return the result of the reinjection-method invocation. */ public Object reinject(final Class<?> key, final Class<?> implementation, final Object instance, final InjectionType reinjectionType) { return reinject(key, implementation, instance, NO_PROPERTIES, reinjectionType); }
protected <T> ComponentAdapter<T> wrapLifeCycle(final Injector<T> injector, final LifecycleStrategy lifecycle) { if (lifecycle instanceof NullLifecycleStrategy) { return injector; } else { return new LifecycleAdapter<T>(injector, lifecycle); } }
@SuppressWarnings("unchecked") public MultiInjector(final Object key, final Class<T> impl, final ComponentMonitor monitor, final String setterPrefix, final boolean useNames, final boolean useAllParameter, final ConstructorParameters constructorParams, final FieldParameters[] fieldParams, final MethodParameters[] methodParams) { super(key, impl, monitor, useNames, monitor.newInjector(new ConstructorInjection.ConstructorInjector<T>(monitor, useNames, key, impl, constructorParams)), monitor.newInjector(new SetterInjection.SetterInjector<T>(key, impl, monitor, setterPrefix, useNames, "", false, methodParams)), monitor.newInjector(new AnnotatedMethodInjection.AnnotatedMethodInjector<T>(key, impl, methodParams, monitor, useNames, useAllParameter, Inject.class, getInjectionAnnotation("javax.inject.Inject"))), monitor.newInjector(new AnnotatedFieldInjection.AnnotatedFieldInjector<T>(key, impl, fieldParams, monitor, useNames, useAllParameter, Inject.class, getInjectionAnnotation("javax.inject.Inject"))) ); }
public AdaptingInjection() { constructorInjection = new Jsr330ConstructorInjection(); methodInjection = new MethodInjection(); setterInjection = new SetterInjection(); annotatedMethodInjection = new AnnotatedMethodInjection(); annotatedFieldInjection = new AnnotatedFieldInjection(); }
/** * Throws an exception if the "resolved" parameter is null <em>unless</em> * {@link #useAllParameters} is set to false. * * @param member * @param i * @param expectedNameBinding * @param result */ @SuppressWarnings("synthetic-access") protected void nullCheck(final AccessibleObject member, final int i, final ParameterNameBinding expectedNameBinding, final Object result) { if (result == null && !isNullParamAllowed(member, i)) { throw new ParameterCannotBeNullException(i, member, expectedNameBinding.getName()); } }
@Override public T run(final Object instance) { final ParameterToAccessibleObjectPair[] matchingParameters = getMatchingParameterListForMembers(guardedContainer); Object componentInstance = makeInstance(container, constructor, currentMonitor()); return decorateComponentInstance(matchingParameters, currentMonitor(), componentInstance, container, guardedContainer, into, null); } };
@Override public String getDescriptor() { if (injectionAnnotationNames == null) { injectionAnnotationNames = makeAnnotationNames(injectionAnnotations); } return "AnnotatedFieldInjector["+injectionAnnotationNames+"]-"; }
private <T> InjectionType fieldAnnotatedInjectionAdapter(final Class<T> impl) { if (injectionFieldAnnotated(impl)) { return this.annotatedFieldInjection; } return null; }