@PostConstruct public void setup() { beanManager = (SyncBeanManagerImpl) IOC.getBeanManager(); activityBeansCache = beanManager.lookupBean( ActivityBeansCache.class ).getInstance(); placeManager = beanManager.lookupBean( PlaceManager.class ).getInstance(); }
@SuppressWarnings({ "rawtypes" }) @Override public Collection<SyncBeanDef> lookupBeans(final String name) { return lookupBeans(name, false); }
@Override public void destroyBean(final Object ref) { innerBeanManager.destroyBean(ref); }
private void init() { final Collection<FactoryHandle> eager = addFactories(); initializeEagerBeans(eager); }
private DefaultPerspectiveEditorScreenActivity createNewScreen( PerspectiveEditor editor ) { DefaultPerspectiveEditorScreenActivity activity = new DefaultPerspectiveEditorScreenActivity(editor, placeManager ); beanManager.addBean( (Class) Activity.class, DefaultPerspectiveEditorScreenActivity.class, null, activity, DEFAULT_QUALIFIERS, activity.getName(), true, null ); beanManager.addBean( (Class) WorkbenchScreenActivity.class, DefaultPerspectiveEditorScreenActivity.class, null, activity, DEFAULT_QUALIFIERS, activity.getName(), true, null ); beanManager.addBean( (Class) DefaultPerspectiveEditorScreenActivity.class, DefaultPerspectiveEditorScreenActivity.class, null, activity, DEFAULT_QUALIFIERS, activity.getName(), true, null ); activityBeansCache.addNewScreenActivity( beanManager.lookupBeans( activity.getName() ).iterator().next() ); return activity; }
public void reset() { typeNamesByName.clear(); unloadedByTypeName.clear(); innerBeanManager.reset(); }
@Override public void callback(final Factory<T> factory) { innerBeanManager.addFactory(factory); unregisterAsyncBean(handle); whenLoaded.run(); } });
@Override public boolean addDestructionCallback(final Object beanInstance, final DestructionCallback<?> destructionCallback) { return innerBeanManager.addDestructionCallback(beanInstance, destructionCallback); }
@Override public ClientBeanManager getNewBeanManager() { if (!GWT.isClient()) { return new SyncBeanManagerImpl(); } else { return null; } } };
/** * For testing only. Resets the bean manager. */ public static void reset() { if (inst.beanManager instanceof SyncBeanManagerImpl) { ((SyncBeanManagerImpl) inst.beanManager).reset(); } else if (inst.beanManager instanceof AsyncBeanManagerImpl) { ((AsyncBeanManagerImpl) inst.beanManager).reset(); } else { throw new RuntimeException("Cannot reset bean manager of type " + inst.beanManager.getClass().getName()); } } }
private void createNewPerspective( PerspectiveEditor editor, DefaultPerspectiveEditorScreenActivity screen ) { final DefaultPerspectiveEditorActivity activity = new DefaultPerspectiveEditorActivity( editor, screen ); beanManager.addBean( (Class) PerspectiveActivity.class, DefaultPerspectiveEditorActivity.class, null, activity, DEFAULT_QUALIFIERS, editor.getName(), true, null ); activityBeansCache.addNewPerspectiveActivity( beanManager.lookupBeans( editor.getName() ).iterator().next() ); }
private Collection<FactoryHandle> addFactories() { final Collection<FactoryHandle> eager = new ArrayList<>(); logger.debug("Adding factories..."); final long start = System.currentTimeMillis(); final Collection<FactoryHandle> allFactoryHandles = contextManager.getAllFactoryHandles(); for (final FactoryHandle handle : allFactoryHandles) { if (handle.isEager()) { eager.add(handle); } addFactory(handle); } final long duration = System.currentTimeMillis() - start; logger.debug("Added {} factories in {}ms.", allFactoryHandles.size(), duration); return eager; }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public <T> Collection<SyncBeanDef<T>> lookupBeans(final Class<T> type) { return (Collection) lookupBeans(type.getName()); }
@Test public void shouldNotLeakUnauthorizedActivityInstances() throws Exception { when(authzManager.authorize(any(Resource.class), eq(dorothy))).thenReturn(false); activityManager.getActivities(kansas); // this overspecified; all we care is that any activity that was created has also been destroyed. // it would be equally okay if the bean was never instantiated in the first place. verify(activityBeansCache).getActivity("kansas"); verify(iocManager).destroyBean(kansasActivity); }
@Override public boolean isActivated() { final Class<? extends BeanActivator> activatorType = handle.getBeanActivatorType(); if (activatorType == null) { return true; } else { final BeanActivator activator = lookupBean(activatorType).getInstance(); return activator.isActivated(); } }
@BeforeClass public static void setupBeans() { ((SyncBeanManagerImpl) IOC.getBeanManager()).reset(); IOC.getBeanManager().registerBean(new MockIOCBeanDef<ObservablePath, ObservablePathImpl>(new ObservablePathImpl(), ObservablePath.class, Dependent.class, new HashSet<Annotation>(Arrays.asList(QualifierUtil.DEFAULT_QUALIFIERS)), null, true)); }
public void addFactory(final Factory<?> factory) { contextManager.addFactory(factory); addFactory(factory.getHandle()); } }
@Override public <T> Collection<SyncBeanDef<T>> lookupBeans(final Class<T> type, final Annotation... qualifiers) { final Set<Annotation> qualifierSet = new HashSet<>(Arrays.asList(qualifiers)); final Collection<SyncBeanDef<T>> candidates = lookupBeans(type); final Iterator<SyncBeanDef<T>> iter = candidates.iterator(); while (iter.hasNext()) { final SyncBeanDef<T> beanDef = iter.next(); if (!beanDef.matches(qualifierSet)) { iter.remove(); } } return candidates; }
@Test public void shouldNotLeakUnauthorizedActivityInstances() throws Exception { when(authzManager.authorize(any(Resource.class), eq(dorothy))).thenReturn(false); activityManager.getActivities(kansas); // this overspecified; all we care is that any activity that was created has also been destroyed. // it would be equally okay if the bean was never instantiated in the first place. verify(activityBeansCache).getActivity("kansas"); verify(iocManager).destroyBean(kansasActivity); }
@SuppressWarnings("unchecked") private <T> SyncBeanDef<T> makeDependentBean(final Class<T> type, final T beanInstance) { final SyncBeanDef<T> beanDef = new MockIOCBeanDef<T, T>(beanInstance, type, Dependent.class, null, beanInstance.getClass().getSimpleName(), true); when((IOCBeanDef<T>) iocManager.lookupBean(beanInstance.getClass())).thenReturn(beanDef); return beanDef; }