private Key<Set<Map.Entry<K, javax.inject.Provider<V>>>> getEntrySetJavaxProviderKey() { Key<Set<Map.Entry<K, javax.inject.Provider<V>>>> local = entrySetJavaxProviderKey; if (local == null) { local = entrySetJavaxProviderKey = mapKey.ofType(setOfEntryOfJavaxProviderOf(keyType, valueType)); } return local; }
Key<Collection<javax.inject.Provider<T>>> getCollectionOfJavaxProvidersKey() { Key<Collection<javax.inject.Provider<T>>> local = collectionOfJavaxProvidersKey; if (local == null) { local = collectionOfJavaxProvidersKey = setKey.ofType(collectionOfJavaxProvidersOf(elementType)); } return local; }
private Key<Map<K, javax.inject.Provider<V>>> getJavaxProviderMapKey() { Key<Map<K, javax.inject.Provider<V>>> local = javaxProviderMapKey; if (local == null) { local = javaxProviderMapKey = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType)); } return local; }
private Key<Map<K, Collection<Provider<V>>>> getProviderCollectionMultimapKey() { Key<Map<K, Collection<Provider<V>>>> local = providerCollectionMultimapKey; if (local == null) { local = providerCollectionMultimapKey = mapKey.ofType(mapOfCollectionOfProviderOf(keyType, valueType)); } return local; }
private Key<Map<K, Collection<javax.inject.Provider<V>>>> getJavaxProviderCollectionMultimapKey() { Key<Map<K, Collection<javax.inject.Provider<V>>>> local = javaxProviderCollectionMultimapKey; if (local == null) { local = javaxProviderCollectionMultimapKey = mapKey.ofType(mapOfCollectionOfJavaxProviderOf(keyType, valueType)); } return local; }
private Key<Map<K, Provider<V>>> getProviderMapKey() { Key<Map<K, Provider<V>>> local = providerMapKey; if (local == null) { local = providerMapKey = mapKey.ofType(mapOfProviderOf(keyType, valueType)); } return local; }
private Key<Map<K, Set<Provider<V>>>> getProviderSetMultimapKey() { Key<Map<K, Set<Provider<V>>>> local = providerSetMultimapKey; if (local == null) { local = providerSetMultimapKey = mapKey.ofType(mapOfSetOfProviderOf(keyType, valueType)); } return local; }
private Key<Map<K, Set<javax.inject.Provider<V>>>> getJavaxProviderSetMultimapKey() { Key<Map<K, Set<javax.inject.Provider<V>>>> local = javaxProviderSetMultimapKey; if (local == null) { local = javaxProviderSetMultimapKey = mapKey.ofType(mapOfSetOfJavaxProviderOf(keyType, valueType)); } return local; }
Key<Collection<Provider<T>>> getCollectionOfProvidersKey() { Key<Collection<Provider<T>>> local = collectionOfProvidersKey; if (local == null) { local = collectionOfProvidersKey = setKey.ofType(collectionOfProvidersOf(elementType)); } return local; }
/** Gets the key of this key's provider. */ Key<Provider<T>> providerKey() { return ofType(typeLiteral.providerType()); }
private Key<Map<K, Set<V>>> getMultimapKey() { Key<Map<K, Set<V>>> local = multimapKey; if (local == null) { local = multimapKey = mapKey.ofType(mapOf(keyType, setOf(valueType))); } return local; }
@SuppressWarnings("unchecked") private void bindJava8Optional(Binder binder) { if (JAVA_OPTIONAL_CLASS != null) { Key<?> key = bindingSelection.getDirectKey(); TypeLiteral<?> typeLiteral = key.getTypeLiteral(); InternalProviderInstanceBindingImpl.Factory<Object> javaOptionalProviderFactory = new JavaOptionalProviderProvider(bindingSelection); binder .bind(key.ofType(javaOptionalOfProvider(typeLiteral))) .toProvider((Provider) javaOptionalProviderFactory); // Provider is assignable to javax.inject.Provider and the provider that the factory contains // cannot be modified so we can use some rawtypes hackery to share the same implementation. binder .bind(key.ofType(javaOptionalOfJavaxProvider(typeLiteral))) .toProvider((Provider) javaOptionalProviderFactory); Key<?> javaOptionalKey = key.ofType(javaOptionalOf(typeLiteral)); binder .bind(javaOptionalKey) .toProvider(new JavaOptionalProvider(bindingSelection, javaOptionalKey)); } }
@SuppressWarnings("unchecked") static <T> Key<Provider<T>> providerOf(Key<T> key) { Type providerT = Types.providerOf(key.getTypeLiteral().getType()); return (Key<Provider<T>>) key.ofType(providerT); }
static <K, V> RealMapBinder<K, V> newRealMapBinder( Binder binder, TypeLiteral<K> keyType, Key<V> valueTypeAndAnnotation) { binder = binder.skipSources(RealMapBinder.class); TypeLiteral<V> valueType = valueTypeAndAnnotation.getTypeLiteral(); return newRealMapBinder( binder, keyType, valueType, valueTypeAndAnnotation.ofType(mapOf(keyType, valueType)), RealMultibinder.newRealSetBinder( binder, valueTypeAndAnnotation.ofType(entryOfProviderOf(keyType, valueType)))); }
private static <T> Key<T> getProvidedKey(Key<Provider<T>> key, Errors errors) throws ErrorsException { Type providerType = key.getTypeLiteral().getType(); // If the Provider has no type parameter (raw Provider)... if (!(providerType instanceof ParameterizedType)) { throw errors.cannotInjectRawProvider().toException(); } Type entryType = ((ParameterizedType) providerType).getActualTypeArguments()[0]; @SuppressWarnings("unchecked") // safe because T came from Key<Provider<T>> Key<T> providedKey = (Key<T>) key.ofType(entryType); return providedKey; }
/** Given a Key<T> will return a Key<Provider<T>> */ @SuppressWarnings("unchecked") private static <T> Key<Provider<T>> getKeyOfProvider(Key<T> valueKey) { return (Key<Provider<T>>) valueKey.ofType(Types.providerOf(valueKey.getTypeLiteral().getType())); }
BindingSelection(Key<T> key) { this.setKey = key.ofType(setOf(key.getTypeLiteral())); this.elementType = key.getTypeLiteral(); }
new RealOptionalProviderProvider<T>(bindingSelection); binder .bind(key.ofType(optionalOfProvider(key.getTypeLiteral()))) .toProvider(optionalProviderFactory); (InternalProviderInstanceBindingImpl.Factory) optionalProviderFactory; binder .bind(key.ofType(optionalOfJavaxProvider(key.getTypeLiteral()))) .toProvider(optionalJavaxProviderFactory); Key<Optional<T>> optionalKey = key.ofType(optionalOf(key.getTypeLiteral())); binder .bind(optionalKey)
@Override public Set<Dependency<?>> getDependencies() { // We depend on Provider<T>, not T directly. This is an important distinction // for dependency analysis tools that short-circuit on providers. Key<?> providerKey = getKey().ofType(Types.providerOf(getKey().getTypeLiteral().getType())); return ImmutableSet.<Dependency<?>>of(Dependency.get(providerKey)); }
throws ErrorsException { Key<String> stringKey = key.ofType(STRING_TYPE); BindingImpl<String> stringBinding = state.getExplicitBinding(stringKey); if (stringBinding == null || !stringBinding.isConstant()) {