@Override public void injectMembers(T instance) { MembersInjector<T> local = delegate; if (local == null) { throw new IllegalStateException( "This MembersInjector cannot be used until the Injector has been created."); } local.injectMembers(instance); }
@Override @SuppressWarnings("unchecked") // the members injector type is consistent with instance's type public void injectMembers(Object instance) { MembersInjector membersInjector = getMembersInjector(instance.getClass()); membersInjector.injectMembers(instance); }
void injectMembers(T t, InternalContext context, boolean toolableOnly) throws InternalProvisionException { ImmutableList<SingleMemberInjector> localMembersInjectors = memberInjectors; if (localMembersInjectors != null) { // optimization: use manual for/each to save allocating an iterator here for (int i = 0, size = localMembersInjectors.size(); i < size; i++) { SingleMemberInjector injector = localMembersInjectors.get(i); if (!toolableOnly || injector.getInjectionPoint().isToolable()) { injector.inject(context, t); } } } // TODO: There's no way to know if a user's MembersInjector wants toolable injections. if (!toolableOnly) { ImmutableList<MembersInjector<? super T>> localUsersMembersInjectors = userMembersInjectors; if (localUsersMembersInjectors != null) { // optimization: use manual for/each to save allocating an iterator here for (int i = 0; i < localUsersMembersInjectors.size(); i++) { MembersInjector<? super T> userMembersInjector = localUsersMembersInjectors.get(i); try { userMembersInjector.injectMembers(t); } catch (RuntimeException e) { throw InternalProvisionException.errorInUserInjector( userMembersInjector, typeLiteral, e); } } } } }
@Test public void testPropertySetting() throws Exception { IMocksControl control = createControl(); TypeEncounter<SomeInjectableBean> encounter = control.createMock(TypeEncounter.class); Provider<Injector> injectorProvider = control.createMock(Provider.class); Injector injector = control.createMock(Injector.class); expect(encounter.getProvider(Injector.class)).andReturn(injectorProvider); expect(injectorProvider.get()).andReturn(injector).anyTimes(); Capture<MembersInjector<SomeInjectableBean>> capture = new Capture<MembersInjector<SomeInjectableBean>>(); encounter.register(and(anyObject(MembersInjector.class), capture(capture))); SecurityManager securityManager = control.createMock(SecurityManager.class); String property = "myPropertyValue"; expect(injector.getInstance(Key.get(SecurityManager.class))).andReturn(securityManager); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.myProperty")))).andReturn(property); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.unavailableProperty")))) .andThrow(new ConfigurationException(Collections.singleton(new Message("Not Available!")))); expect((Map)injector.getInstance(BeanTypeListener.MAP_KEY)).andReturn(Collections.EMPTY_MAP).anyTimes(); control.replay(); BeanTypeListener underTest = new BeanTypeListener(); underTest.hear(TypeLiteral.get(SomeInjectableBean.class), encounter); SomeInjectableBean bean = new SomeInjectableBean(); capture.getValue().injectMembers(bean); assertSame(securityManager, bean.securityManager); assertSame(property, bean.myProperty); assertNull(bean.unavailableProperty); control.verify(); }
public T get() { membersInjector.injectMembers(component); return component; } };
public Filter get() { membersInjector.injectMembers( filter ); return filter; } };
public Filter get() { membersInjector.injectMembers(filter); return filter; } };
@Override public void injectMembers(T instance) { MembersInjector<T> local = delegate; if (local == null) { throw new IllegalStateException( "This MembersInjector cannot be used until the Injector has been created."); } local.injectMembers(instance); }
@Override public void injectMembers(T instance) { MembersInjector<T> local = delegate; if (local == null) { throw new IllegalStateException( "This MembersInjector cannot be used until the Injector has been created."); } local.injectMembers(instance); }
public void injectMembers(T instance) { checkState(delegate != null, "This MembersInjector cannot be used until the Injector has been created."); delegate.injectMembers(instance); }
@Inject private void injectAdapter(MembersInjector<JmsAdapter> jmsAdapterMembersInjector) { jmsAdapterMembersInjector.injectMembers(this.adapter); }
public <T> void injectResources(T object) { Class clz = object.getClass(); Iterable<MembersInjector> inj = injectors.get(clz); if (inj == null) { inj = retriveMemberInjectors(clz); injectors.put(clz, inj); } for (MembersInjector mi : inj) { mi.injectMembers(object); } }
@SuppressWarnings("unchecked") // the members injector type is consistent with instance's type public void injectMembers(Object instance) { MembersInjector membersInjector = getMembersInjector(instance.getClass()); membersInjector.injectMembers(instance); }
public void injectMembers(T instance) { checkState(delegate != null, "This MembersInjector cannot be used until the Injector has been created."); delegate.injectMembers(instance); }
public PartitionDeletionEditStrategy newInstance(String left, String right) { PartitionDeletionEditStrategy result = new PartitionDeletionEditStrategy(left,right); injector.injectMembers(result); return result; } }
@Override @SuppressWarnings("unchecked") // the members injector type is consistent with instance's type public void injectMembers(Object instance) { MembersInjector membersInjector = getMembersInjector(instance.getClass()); membersInjector.injectMembers(instance); }
public void injectMembers(T instance) { checkState(delegate != null, "This MembersInjector cannot be used until the Injector has been created."); delegate.injectMembers(instance); }
@Override @SuppressWarnings("unchecked") // the members injector type is consistent with instance's type public void injectMembers(Object instance) { MembersInjector membersInjector = getMembersInjector(instance.getClass()); membersInjector.injectMembers(instance); }
public PartitionInsertEditStrategy newInstance(String left, String right) { PartitionInsertEditStrategy result = new PartitionInsertEditStrategy(left,right); injector.injectMembers(result); return result; } }
public SingleLineTerminalsStrategy newInstance(String left, String right, StrategyPredicate predicate) { SingleLineTerminalsStrategy strategy = new SingleLineTerminalsStrategy(left, right, predicate); injector.injectMembers(strategy); return strategy; } }