private static String instantiation(Binding<?> binding) { if (binding instanceof InstanceBinding<?>) { return instanceLiteral((InstanceBinding<?>) binding); } else if (binding instanceof ProviderKeyBinding<?>) { return providerCall(((ProviderKeyBinding<?>) binding).getProviderKey()) + ".get()"; } else if (binding instanceof LinkedKeyBinding<?>) { return providerCall(((LinkedKeyBinding<?>) binding).getLinkedKey()); } else if (binding instanceof ConstructorBinding<?>) { return constructorCall((ConstructorBinding<?>) binding); } else if (binding instanceof ProviderBinding<?>) { return provider((ProviderBinding<?>) binding); } else if (binding instanceof ProviderInstanceBinding<?>) { return instantiation((ProviderInstanceBinding<?>) binding); } else { throw new DeguicifierException(); } }
@Override public <T> Collection<T> getBeansOfType(Class<T> clazz) { Injector injector = ensureInjector(); List<T> beans = new ArrayList<T>(); Map<Key<?>, Binding<?>> bindings = injector.getBindings(); for( Binding<?> binding : bindings.values() ) { Key<?> actualKey = null; if( binding instanceof UntargettedBinding || binding instanceof ConstructorBinding ) { actualKey = binding.getKey(); } else if( binding instanceof LinkedKeyBinding ) { actualKey = ((LinkedKeyBinding<?>) binding).getLinkedKey(); } else if( binding instanceof ProviderBinding ) { actualKey = ((ProviderBinding<?>) binding).getProvidedKey(); } if( actualKey != null && clazz.isAssignableFrom(actualKey.getTypeLiteral().getRawType()) ) { beans.add(clazz.cast(binding.getProvider().get())); } } return beans; }
@Test public void binds_provider_implicitly() { given(module = new AbstractModule() { @Override protected void configure() {} }); given(injector = Guice.createInjector(module)); when(injector.getBinding(Key.get(new TypeLiteral<Provider<Implementation>>() {}))); thenReturned(instanceOf(ProviderBinding.class)); }
/** * Visitor for {@link ProviderBinding}. These {@link Binding}s arise from an {@link * InjectionPoint} for the {@link Provider} interface. */ @Override public Collection<Edge> visit(ProviderBinding<?> binding) { return ImmutableList.<Edge>of( new BindingEdge( NodeId.newTypeId(binding.getKey()), NodeId.newTypeId(binding.getProvidedKey()), BindingEdge.Type.PROVIDER)); }
@Override public Iterable<Alias> createAliases(Iterable<Binding<?>> bindings) { List<Alias> aliases = Lists.newArrayList(); for (Binding<?> binding : bindings) { if (binding instanceof ProviderBinding) { aliases.add( new Alias( NodeId.newTypeId(binding.getKey()), NodeId.newTypeId(((ProviderBinding<?>) binding).getProvidedKey()))); } } return aliases; }
@Override public Indexer.IndexedBinding visit(ProviderBinding<? extends Object> binding) { return new Indexer.IndexedBinding( binding, BindingType.PROVIDED_BY, scope(binding), injector.getBinding(binding.getProvidedKey())); }
@Override public String toString() { return MoreObjects.toStringHelper(ProviderBinding.class) .add("key", getKey()) .add("providedKey", getProvidedKey()) .toString(); }
@Override public Iterable<Alias> createAliases(Iterable<Binding<?>> bindings) { List<Alias> aliases = Lists.newArrayList(); for (Binding<?> binding : bindings) { if (binding instanceof ProviderBinding) { aliases.add(new Alias(NodeId.newTypeId(binding.getKey()), NodeId.newTypeId(((ProviderBinding<?>) binding).getProvidedKey()))); } } return aliases; }
@Override public Optional<TypeLiteral<?>> visit(ProviderBinding<?> binding) { // Delegate to the binding for the provided type return injector.getBinding(binding.getProvidedKey()).acceptTargetVisitor(this); }
@Override public Object visit(ProviderBinding<? extends T> providerBinding) { requireKey(providerBinding.getProvidedKey()); return super.visit(providerBinding); }
@Override public Void visit(ProviderBinding<? extends T> binding) { // These are only created internally, not sure why we would ever see it scope(binding, rebind(binding).toProvider(binding.getProvider())); return null; }
private static String provider(ProviderBinding<?> binding) { Key<?> key = binding.getProvidedKey(); TypeLiteral<?> type = key.getTypeLiteral(); return provider(type, providerCall(key)); }
@Override public Collection<Key<?>> visit(ProviderBinding<?> binding) { return ImmutableSet.<Key<?>>of(binding.getProvidedKey()); }
public void testVisitProviderBinding() { Binding<?> binding = getBinding(Key.get(new TypeLiteral<Provider<ConstructedClass>>() {})); Collection<Key<?>> dependencies = visitor.visit((ProviderBinding<?>) binding); assertDependencies(dependencies, Key.get(ConstructedClass.class)); }
@Override public ResolvedBinding<T> visit(ProviderBinding<? extends T> providerBinding) { //noinspection unchecked return traverse((Key<? extends T>)providerBinding.getProvidedKey()); }
/** * Visitor for {@link ProviderBinding}. These {@link Binding}s arise from an * {@link InjectionPoint} for the {@link Provider} interface. */ @Override public Collection<Edge> visit(ProviderBinding<?> binding) { return ImmutableList.<Edge>of(new BindingEdge(NodeId.newTypeId(binding.getKey()), NodeId.newTypeId(binding.getProvidedKey()), BindingEdge.Type.PROVIDER)); }
@Override public String toString() { return Objects.toStringHelper(ProviderBinding.class) .add("key", getKey()) .add("providedKey", getProvidedKey()) .toString(); }