org.picocontainer.MutablePicoContainer Java Examples

private void registerCodeStyleManager(CodeStyleManager manager) {
	if (ApplicationInfo.getInstance().getBuild().getBaselineVersion() >= 193) {
		IdeaPluginDescriptor plugin = PluginManagerCore.getPlugin(PluginId.getId("spring-javaformat"));
		try {
			((ComponentManagerImpl) this.project).registerServiceInstance(CodeStyleManager.class, manager, plugin);
		}
		catch (NoSuchMethodError ex) {
			Method method = findRegisterServiceInstanceMethod(this.project.getClass());
			invokeRegisterServiceInstanceMethod(manager, plugin, method);
		}
	}
	else {
		MutablePicoContainer container = (MutablePicoContainer) this.project.getPicoContainer();
		container.unregisterComponent(CODE_STYLE_MANAGER_KEY);
		container.registerComponentInstance(CODE_STYLE_MANAGER_KEY, manager);
	}
}
 

@Before
public final void setup() {
  testDisposable = new RootDisposable();
  TestUtils.createMockApplication(testDisposable);
  MutablePicoContainer applicationContainer =
      (MutablePicoContainer) ApplicationManager.getApplication().getPicoContainer();
  MockProject mockProject = TestUtils.mockProject(applicationContainer, testDisposable);

  extensionsArea = (ExtensionsAreaImpl) Extensions.getRootArea();

  this.project = mockProject;

  initTest(
      new Container((MockComponentManager) ApplicationManager.getApplication(), testDisposable),
      new Container(mockProject, testDisposable));
}
 

public static <T> void registerApplicationComponent(
    Class<T> key, T implementation, Disposable parentDisposable) {
  Application application = ApplicationManager.getApplication();
  // #api193 (or #api201?): ComponentManagerImpl moved in 2020.1 dot releases. Check
  // ComponentManagerImpl directly when earlier releases are no longer supported
  boolean isComponentManagerImpl = !(application instanceof MockApplication);
  if (isComponentManagerImpl) {
    ServiceContainerUtil.registerComponentInstance(
        application, key, implementation, parentDisposable);
  } else {
    registerComponentInstance(
        (MutablePicoContainer) application.getPicoContainer(),
        key,
        implementation,
        parentDisposable);
  }
}
 

private static <T> void registerComponentInstance(
    MutablePicoContainer container, Class<T> key, T implementation, Disposable parentDisposable) {
  Object old;
  try {
    old = container.getComponentInstance(key);
  } catch (UnsatisfiableDependenciesException e) {
    old = null;
  }
  container.unregisterComponent(key.getName());
  container.registerComponentInstance(key.getName(), implementation);
  Object finalOld = old;
  Disposer.register(
      parentDisposable,
      () -> {
        container.unregisterComponent(key.getName());
        if (finalOld != null) {
          container.registerComponentInstance(key.getName(), finalOld);
        }
      });
}
 

private static <T> void registerService(
    ComponentManager componentManager,
    Class<T> key,
    T implementation,
    Disposable parentDisposable) {
  boolean exists = componentManager.getService(key) != null;
  if (exists) {
    // upstream code can do it all for us
    ServiceContainerUtil.replaceService(componentManager, key, implementation, parentDisposable);
    return;
  }

  // otherwise we should manually unregister on disposal
  ServiceContainerUtil.registerServiceInstance(componentManager, key, implementation);
  Disposer.register(
      parentDisposable,
      () ->
          ((MutablePicoContainer) componentManager.getPicoContainer())
              .unregisterComponent(key.getName()));
}
 

/**
 * Configures the gml3 context.
 * <p>
 * The following factories are registered:
 * <ul>
 * <li>{@link CoordinateArraySequenceFactory} under {@link CoordinateSequenceFactory}
 * <li>{@link GeometryFactory}
 * </ul>
 * </p>
 */
public void configureContext(MutablePicoContainer container) {
    super.configureContext(container);

    container.registerComponentInstance(new FeatureTypeCache());
    container.registerComponentInstance(new XSDIdRegistry());

    //factories
    container.registerComponentInstance(CoordinateSequenceFactory.class,
        CoordinateArraySequenceFactory.instance());
    container.registerComponentImplementation(GeometryFactory.class);
    
    container.registerComponentInstance(new GML3EncodingUtils());
    
    if (isExtendedArcSurfaceSupport()) {
        container.registerComponentInstance(new ArcParameters());
    }

    container.registerComponentInstance(srsSyntax);
}
 

private static <T> void registerComponentInstance(
    MutablePicoContainer container, Class<T> key, T implementation, Disposable parentDisposable) {
  Object old;
  try {
    old = container.getComponentInstance(key);
  } catch (UnsatisfiableDependenciesException e) {
    old = null;
  }
  container.unregisterComponent(key.getName());
  container.registerComponentInstance(key.getName(), implementation);
  Object finalOld = old;
  Disposer.register(
      parentDisposable,
      () -> {
        container.unregisterComponent(key.getName());
        if (finalOld != null) {
          container.registerComponentInstance(key.getName(), finalOld);
        }
      });
}
 

public static void register() {
    LightPlatformTestCase.initApplication();
    MutablePicoContainer container = (MutablePicoContainer) ApplicationManager.getApplication().getPicoContainer();

    container.unregisterComponent(ExecutorService.class.getName());
    container.registerComponentInstance(ExecutorService.class.getName(), new DummyExecutorService());
}
 

private static MutablePicoContainer 初始化容器() {
	MutablePicoContainer pico = new DefaultPicoContainer();
	pico.addComponent(IocBookStore.class);
	pico.addComponent(BookReader.class);
	
	return pico;
}
 

private static void 使用容器的方式(String author) throws DataInitException {
	MutablePicoContainer 容器 = 初始化容器();
	
	_store = 容器.getComponent(IStore.class);
	_store.init();
	authorBy(author);
}
 

public static <T> void registerProjectComponent(
    Project project, Class<T> key, T implementation, Disposable parentDisposable) {
  // #api193 (or #api201?): ComponentManagerImpl moved in 2020.1 dot releases. Check
  // ComponentManagerImpl directly when earlier releases are no longer supported
  boolean isComponentManagerImpl = project instanceof ProjectImpl;
  if (isComponentManagerImpl) {
    ServiceContainerUtil.registerComponentInstance(
        project, key, implementation, parentDisposable);
  } else {
    registerComponentInstance(
        (MutablePicoContainer) project.getPicoContainer(), key, implementation, parentDisposable);
  }
}
 

public <T> void registerApplicationComponent(Class<T> klass, T instance) {
  registerComponentInstance(
      (MutablePicoContainer) ApplicationManager.getApplication().getPicoContainer(),
      klass,
      instance,
      testDisposable);
}
 

public <T> void registerApplicationService(Class<T> klass, T instance) {
  registerComponentInstance(
      (MutablePicoContainer) ApplicationManager.getApplication().getPicoContainer(),
      klass,
      instance,
      testDisposable);
}
 

public DiffAppendersModule(JaversCoreConfiguration javersCoreConfiguration, MutablePicoContainer container) {
    super(javersCoreConfiguration, container);
    this.listChangeAppender = javersCoreConfiguration.getListCompareAlgorithm().getAppenderClass();
}
 

public GraphFactoryModule(MutablePicoContainer container) {
    super(container);
}
 

public TailoredJaversMemberFactoryModule(JaversCoreConfiguration configuration, MutablePicoContainer container) {
    super(configuration, container);
}
 

protected MutablePicoContainer getContainer() {
    return container;
}
 

public AddOnsModule(MutablePicoContainer container, Collection<Class> implementations) {
    super(container);
    this.implementations = new HashSet<>(implementations);
}
 

public LateInstantiatingModule(JaversCoreConfiguration configuration, MutablePicoContainer container) {
    super(container);
    this.configuration = configuration;
}
 

public InstantiatingModule(MutablePicoContainer container) {
    this.container = container;
    this.argumentResolver = new ContainerArgumentResolver(container);
}
 

public SnapshotModule(MutablePicoContainer container) {
    super(container);
}
 

public CoreJaversModule(MutablePicoContainer container) {
    super(container);
}
 

public <T> void registerProjectComponent(Class<T> klass, T instance) {
  registerComponentInstance(
      (MutablePicoContainer) getProject().getPicoContainer(), klass, instance, testDisposable);
}
 

public ChangeTypeAdaptersModule(MutablePicoContainer container) {
    super(container);
}
 

public CommitTypeAdaptersModule(MutablePicoContainer container) {
    super(container);
}
 

public CommitFactoryModule(MutablePicoContainer container) {
    super(container);
}
 

public TypeMapperModule(MutablePicoContainer container) {
    super(container);
}
 

public ScannerModule(JaversCoreConfiguration configuration, MutablePicoContainer container) {
    super(configuration, container);
}
 

public ShadowModule(MutablePicoContainer container) {
    super(container);
}
 

public JqlModule(MutablePicoContainer container) {
    super(container);
}