@Override public Map<Key<?>, Binding<?>> getAllBindings() { return this.delegateInjector.getAllBindings(); }
public Map<Key<?>, Binding<?>> getAllBindings() { return resolve().getAllBindings(); }
@Inject public GuiceQueryPreProcessor(Injector injector) { m_preProcessors = new ArrayList<>(); Map<Key<?>, Binding<?>> bindings = injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (QueryPreProcessor.class.isAssignableFrom(bindingClass)) { m_preProcessors.add((QueryPreProcessor)injector.getInstance(bindingClass)); } } }
@Inject public HealthCheckServiceImpl(Injector injector) { checkNotNull(injector); Map<Key<?>, Binding<?>> bindings = injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (HealthStatus.class.isAssignableFrom(bindingClass)) { checks.add((HealthStatus) injector.getInstance(bindingClass)); } } }
public Config getPluginConfigProxy(Plugin plugin) { final Injector injector = plugin.getInjector(); for (Key<?> key : injector.getAllBindings().keySet()) { Class<?> type = key.getTypeLiteral().getRawType(); if (Config.class.isAssignableFrom(type)) { return (Config) injector.getInstance(key); } } return null; }
@Inject public GuiceCommandProvider(Injector injector) { Map<Key<?>, Binding<?>> bindings = injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (TelnetCommand.class.isAssignableFrom(bindingClass)) { TelnetCommand command = (TelnetCommand)injector.getInstance(bindingClass); m_commandMap.put(command.getCommand(), command); } } }
@Inject @SuppressWarnings("unchecked") public GuiceQueryPluginFactory(Injector injector) { m_injector = injector; Map<Key<?>, Binding<?>> bindings = injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (QueryPlugin.class.isAssignableFrom(bindingClass)) { PluginName ann = (PluginName) bindingClass.getAnnotation(PluginName.class); if (ann == null) throw new IllegalStateException("QueryPlugin class " + bindingClass.getName() + " does not have required annotation " + PluginName.class.getName()); m_plugins.put(ann.name(), (Class<QueryPlugin>)bindingClass); } } }
public void startServices() throws KairosDBException { Map<Key<?>, Binding<?>> bindings = m_injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (KairosDBService.class.isAssignableFrom(bindingClass)) { KairosDBService service = (KairosDBService) m_injector.getInstance(bindingClass); logger.info("Starting service " + bindingClass); service.start(); m_services.add(service); } } }
public List<Config> getPluginConfigProxies() { List<Injector> injectors = new ArrayList<>(); injectors.add(RuneLite.getInjector()); getPlugins().forEach(pl -> injectors.add(pl.getInjector())); List<Config> list = new ArrayList<>(); for (Injector injector : injectors) { for (Key<?> key : injector.getAllBindings().keySet()) { Class<?> type = key.getTypeLiteral().getRawType(); if (Config.class.isAssignableFrom(type)) { Config config = (Config) injector.getInstance(key); list.add(config); } } } return list; }
@Inject public GuiceKairosDataPointFactory(Injector injector, KairosRootConfig props) Map<Key<?>, Binding<?>> bindings = injector.getAllBindings();
/** * Constructor of a generic class to easily generate a feature processing factory. * * @param injector Guice {@link Injector} instance needed for binding * @param featureClass feature processor class */ @SuppressWarnings("unchecked") protected GenericFeatureProcessorFactory(@NotNull Injector injector, @NotNull Class<FEATURE> featureClass) throws InvocationTargetException, NoSuchMethodException, ClassNotFoundException, IllegalAccessException { this.injector = injector; this.featureClass = featureClass; Map<Key<?>, Binding<?>> bindings = injector.getAllBindings(); for (Key<?> key : bindings.keySet()) { Class<?> bindingClass = key.getTypeLiteral().getRawType(); if (featureClass.isAssignableFrom(bindingClass)) { FeatureComponent annotation = bindingClass.getAnnotation(FeatureComponent.class); if (annotation == null) throw new IllegalStateException("Processor class " + bindingClass.getName() + " does not have required annotation " + FeatureComponent.class.getName()); featureProcessors.put(annotation.name(), (Class<FEATURE>) bindingClass); List<FeaturePropertyMetadata> properties = getPropertyMetadata(bindingClass); featureProcessorMetadata.add(new FeatureProcessorMetadata(annotation.name(), labelizeComponent(annotation), annotation.description(), properties)); } } featureProcessorMetadata.sort(Comparator.comparing(FeatureProcessorMetadata::getName)); }
for (Key<?> key : guice.getAllBindings().keySet())
private Set<Object> getBeans(Collection<Class<? extends Annotation>> annotations) { Set<Object> beans = U.set(); for (Map.Entry<Key<?>, Binding<?>> e : injector.getAllBindings().entrySet()) { Key<?> key = e.getKey(); Binding<?> value = e.getValue(); boolean include = false; if (U.notEmpty(annotations)) { if (key.getTypeLiteral() != null && key.getTypeLiteral().getRawType() != null) { Class<?> type = key.getTypeLiteral().getRawType(); if (Metadata.isAnnotatedAny(type, annotations)) { include = true; } } } else { include = true; } if (include) { beans.add(value.getProvider().get()); } } return beans; }
Map<Key<?>, Binding<?>> bindingMap = injector.getAllBindings(); for (Key<?> bindingKey : bindingMap.keySet()) { String have = bindingKey.getTypeLiteral().toString();
public void testServletModuleReuse() { Module module = new Module(); Elements.getElements(module); // use the module once (to, say, introspect bindings) Injector injector = Guice.createInjector(module); // use it again. Visitor visitor = new Visitor(); // Validate only a single servlet binding & a single filter binding exist. for (Binding<?> binding : injector.getAllBindings().values()) { binding.acceptTargetVisitor(visitor); } assertEquals( "wrong linked servlets: " + visitor.linkedServlets, 0, visitor.linkedServlets.size()); assertEquals("wrong linked filters: " + visitor.linkedFilters, 0, visitor.linkedFilters.size()); assertEquals( "wrong instance servlets: " + visitor.instanceServlets, 1, visitor.instanceServlets.size()); assertEquals( "wrong instance filters: " + visitor.instanceFilters, 1, visitor.instanceFilters.size()); }
public GovernatorBuilderMapper(Injector injector, ConfigurationProvider configurationProvider, String prefix) { this.configurationProvider = configurationProvider; this.prefix = prefix; this.injector = injector; this.bindings = injector.getAllBindings(); }
private Map<Key<?>, Binding<?>> collectBindings() { ImmutableMap.Builder<Key<?>, Binding<?>> result = ImmutableMap.builder(); Injector current = this.injector; while (current != null) { result.putAll(current.getAllBindings()); current = current.getParent(); } return result.build(); }
private Injector createInjector(final Module... modules) { assert modules != null; Injector injector = Guice.createInjector(new WireModule(modules)); if (log.isTraceEnabled()) { log.trace("Created injector: {} w/bindings:", OID.get(injector)); for (Map.Entry<Key<?>,Binding<?>> entry : injector.getAllBindings().entrySet()) { log.trace(" {} -> {}", entry.getKey(), entry.getValue()); } } return injector; }
private Stream<Class> streamExposedTypes() { Stream<Class> stream = injector.getAllBindings().values().stream() .map(binding -> (Class) binding.getKey().getTypeLiteral().getRawType()) .filter(rawType -> !DEFAULT_GUICE_BINDINGS.contains(rawType)); return stream; }
private void executeStereotypeHandlers() { Set<StereotypeHandler> handlers = injector.getInstance(Key.get(new TypeLiteral<Set<StereotypeHandler>>() {})); for (Key<?> key : injector.getAllBindings().keySet()) { for (StereotypeHandler handler : handlers) { Class<?> type = key.getTypeLiteral().getRawType(); if (type.isAnnotationPresent(handler.stereotype())) { handler.handle(type); } } } }