Examples with Key com.google.inject.Key used on opensource projects

Example 31 with Key

use of com.google.inject.Key in project camel by apache.

the class Injectors method tryCloseJitBindings.

private static void tryCloseJitBindings(Closer closer, Injector injector, Class<? extends Annotation> scopeAnnotationToClose, CloseErrors errors) {
    Class<? extends Injector> type = injector.getClass();
    Field field;
    try {
        field = type.getDeclaredField("jitBindings");
        field.setAccessible(true);
        Object bindings = field.get(injector);
        if (bindings != null) {
            if (bindings instanceof Map) {
                Map<Key<?>, BindingImpl<?>> map = (Map<Key<?>, BindingImpl<?>>) bindings;
                Set<Entry<Key<?>, BindingImpl<?>>> entries = map.entrySet();
                for (Entry<Key<?>, BindingImpl<?>> entry : entries) {
                    closeBinding(entry.getKey(), entry.getValue(), scopeAnnotationToClose, closer, errors);
                }
            }
        }
    } catch (NoSuchFieldException e) {
    // ignore - Guice has refactored so we can't access the jit bindings
    // System.out.println("No such field! " + e);
    } catch (IllegalAccessException e) {
    // ignore - Guice has refactored so we can't access the jit bindings
    // System.out.println("Failed to access field: " + field +
    // ". Reason: " + e);
    }
}

Example 32 with Key

use of com.google.inject.Key in project roboguice by roboguice.

the class SpiBindingsTest method testExtensionSpi.

public void testExtensionSpi() {
    final AtomicBoolean visiting = new AtomicBoolean(false);
    final Injector injector = Guice.createInjector(new AbstractModule() {

        protected void configure() {
            bind(String.class).toProvider(new ProviderWithExtensionVisitor<String>() {

                public <B, V> V acceptExtensionVisitor(BindingTargetVisitor<B, V> visitor, ProviderInstanceBinding<? extends B> binding) {
                    assertSame(this, binding.getUserSuppliedProvider());
                    // to process the binding as normal
                    if (visiting.get()) {
                        assertTrue("visitor: " + visitor, visitor instanceof FailingSpiTargetVisitor);
                        return (V) "visited";
                    } else {
                        return visitor.visit(binding);
                    }
                }

                public String get() {
                    return "FooBar";
                }
            });
        }
    });
    visiting.set(true);
    // Check for Provider<String> binding -- that is still a ProviderBinding.
    Key<Provider<String>> providerOfStringKey = new Key<Provider<String>>() {
    };
    Binding<Provider<String>> providerBinding = injector.getBinding(providerOfStringKey);
    assertEquals(providerOfStringKey, providerBinding.getKey());
    checkBindingSource(providerBinding);
    assertTrue("binding: " + providerBinding, providerBinding instanceof ProviderBinding);
    providerBinding.acceptTargetVisitor(new FailingTargetVisitor<Provider<String>>() {

        @Override
        public Void visit(ProviderBinding<? extends Provider<String>> binding) {
            assertEquals(Key.get(String.class), binding.getProvidedKey());
            return null;
        }
    });
    // Check for String binding -- that one is ProviderInstanceBinding, and gets hooked
    Binding<String> binding = injector.getBinding(String.class);
    assertEquals(Key.get(String.class), binding.getKey());
    checkBindingSource(binding);
    assertTrue(binding instanceof ProviderInstanceBinding);
    assertEquals("visited", binding.acceptTargetVisitor(new FailingSpiTargetVisitor<String>()));
}

Example 33 with Key

use of com.google.inject.Key in project roboguice by roboguice.

the class SpiBindingsTest method testProviderBinding.

public void testProviderBinding() {
    Injector injector = Guice.createInjector(new AbstractModule() {

        protected void configure() {
            bind(String.class).toInstance("A");
        }
    });
    Key<Provider<String>> providerOfStringKey = new Key<Provider<String>>() {
    };
    Binding<Provider<String>> binding = injector.getBinding(providerOfStringKey);
    assertEquals(providerOfStringKey, binding.getKey());
    checkBindingSource(binding);
    assertTrue(binding instanceof ProviderBinding);
    binding.acceptTargetVisitor(new FailingTargetVisitor<Provider<String>>() {

        @Override
        public Void visit(ProviderBinding<? extends Provider<String>> binding) {
            assertEquals(Key.get(String.class), binding.getProvidedKey());
            return null;
        }
    });
}

Example 34 with Key

use of com.google.inject.Key in project roboguice by roboguice.

the class OverrideModuleTest method testOverrideScopeAnnotation.

public void testOverrideScopeAnnotation() {
    final Scope scope = new Scope() {

        public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped) {
            throw new AssertionError("Should not be called");
        }
    };
    final SingleUseScope replacementScope = new SingleUseScope();
    Module original = new AbstractModule() {

        @Override
        protected void configure() {
            bindScope(TestScopeAnnotation.class, scope);
            bind(Date.class).in(TestScopeAnnotation.class);
        }
    };
    Module replacements = new AbstractModule() {

        @Override
        protected void configure() {
            bindScope(TestScopeAnnotation.class, replacementScope);
        }
    };
    Injector injector = createInjector(Modules.override(original).with(replacements));
    injector.getInstance(Date.class);
    assertTrue(replacementScope.used);
}

Example 35 with Key

use of com.google.inject.Key in project roboguice by roboguice.

the class FactoryModuleBuilderTest method testFactoryBindingDependencies.

public void testFactoryBindingDependencies() {
    // validate dependencies work in all stages & as a raw element,
    // and that dependencies work for methods, fields, constructors,
    // and for @AssistedInject constructors too.
    Module module = new AbstractModule() {

        @Override
        protected void configure() {
            bind(Integer.class).toInstance(42);
            bind(Double.class).toInstance(4.2d);
            bind(Float.class).toInstance(4.2f);
            bind(String.class).annotatedWith(named("dog")).toInstance("dog");
            bind(String.class).annotatedWith(named("cat1")).toInstance("cat1");
            bind(String.class).annotatedWith(named("cat2")).toInstance("cat2");
            bind(String.class).annotatedWith(named("cat3")).toInstance("cat3");
            bind(String.class).annotatedWith(named("arbitrary")).toInstance("fail!");
            install(new FactoryModuleBuilder().implement(Animal.class, Dog.class).build(AnimalHouse.class));
        }
    };
    Set<Key<?>> expectedKeys = ImmutableSet.<Key<?>>of(Key.get(Integer.class), Key.get(Double.class), Key.get(Float.class), Key.get(String.class, named("dog")), Key.get(String.class, named("cat1")), Key.get(String.class, named("cat2")), Key.get(String.class, named("cat3")));
    Injector injector = Guice.createInjector(module);
    validateDependencies(expectedKeys, injector.getBinding(AnimalHouse.class));
    injector = Guice.createInjector(Stage.TOOL, module);
    validateDependencies(expectedKeys, injector.getBinding(AnimalHouse.class));
    List<Element> elements = Elements.getElements(module);
    boolean found = false;
    for (Element element : elements) {
        if (element instanceof Binding) {
            Binding<?> binding = (Binding<?>) element;
            if (binding.getKey().equals(Key.get(AnimalHouse.class))) {
                found = true;
                validateDependencies(expectedKeys, binding);
                break;
            }
        }
    }
    assertTrue(found);
}