public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<K, V>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); }
@Override public void configure(Binder binder) { checkConfiguration(!isInitialized(), "OptionalBinder was already initialized"); binder.bind(optionalProviderKey).toProvider(new RealOptionalProviderProvider()); // Optional is immutable, so it's safe to expose Optional<Provider<T>> as // Optional<javax.inject.Provider<T>> (since Guice provider implements javax Provider). @SuppressWarnings({"unchecked", "cast"}) Key massagedOptionalProviderKey = (Key) optionalProviderKey; binder.bind(optionalJavaxProviderKey).to(massagedOptionalProviderKey); binder.bind(optionalKey).toProvider(new RealOptionalKeyProvider()); // Bind the java-8 types if we know them. bindJava8Optional(binder); }
Key<T> getKeyForDefaultBinding() { checkConfiguration(!isInitialized(), "already initialized"); addDirectTypeBinding(binder); return defaultKey; }
Key<T> getKeyForActualBinding() { checkConfiguration(!isInitialized(), "already initialized"); addDirectTypeBinding(binder); return actualKey; }
public Map<K, Set<V>> get() { ImmutableMap.Builder<K, Set<V>> multimapBuilder = ImmutableMap.builder(); for (Entry<K, Set<Provider<V>>> entry : multimapProvider.get().entrySet()) { K key = entry.getKey(); ImmutableSet.Builder<V> valuesBuilder = ImmutableSet.builder(); for (Provider<V> valueProvider : entry.getValue()) { V value = valueProvider.get(); checkConfiguration(value != null, "Multimap injection failed due to null value for key \"%s\"", key); valuesBuilder.add(value); } multimapBuilder.put(key, valuesBuilder.build()); } return multimapBuilder.build(); }
@SuppressWarnings({ "unused", "unchecked" }) @Toolable @Inject void initialize(Injector injector) { RealMapBinder.this.binder = null; permitDuplicates = entrySetBinder.permitsDuplicates(injector); Map<K, Provider<V>> providerMapMutable = new LinkedHashMap<K, Provider<V>>(); List<Map.Entry<K, Binding<V>>> bindingsMutable = Lists.newArrayList(); for (Entry<K, Provider<V>> entry : entrySetProvider.get()) { Provider<V> previous = providerMapMutable.put(entry.getKey(), entry.getValue()); checkConfiguration(previous == null || permitDuplicates, "Map injection failed due to duplicated key \"%s\"", entry.getKey()); Key<V> valueKey = (Key<V>)((MapEntry)entry).getValueKey(); bindingsMutable.add(new MapEntry(entry.getKey(), injector.getBinding(valueKey), valueKey)); } providerMap = ImmutableMap.copyOf(providerMapMutable); mapBindings = ImmutableList.copyOf(bindingsMutable); }
/** * This creates two bindings. One for the {@code Map.Entry<K, Provider<V>>} * and another for {@code V}. */ @Override public LinkedBindingBuilder<V> addBinding(K key) { checkNotNull(key, "key"); checkConfiguration(!isInitialized(), "MapBinder was already initialized"); Key<V> valueKey = Key.get(valueType, new RealElement(entrySetBinder.getSetName())); entrySetBinder.addBinding().toInstance(new MapEntry<K, Provider<V>>(key, binder.getProvider(valueKey), valueKey)); return binder.bind(valueKey); }
@Override public void configure(Binder binder) { checkConfiguration(!isInitialized(), "MapBinder was already initialized"); ImmutableSet<Dependency<?>> dependencies = ImmutableSet.<Dependency<?>>of(Dependency.get(entrySetBinder.getSetKey())); // Binds a Map<K, Provider<V>> from a collection of Set<Entry<K, Provider<V>>. Provider<Set<Entry<K, Provider<V>>>> entrySetProvider = binder .getProvider(entrySetBinder.getSetKey()); binder.bind(providerMapKey).toProvider( new RealProviderMapProvider(dependencies, entrySetProvider)); // The map this exposes is internally an ImmutableMap, so it's OK to massage // the guice Provider to javax Provider in the value (since Guice provider // implements javax Provider). @SuppressWarnings("unchecked") Key massagedProviderMapKey = (Key) providerMapKey; binder.bind(javaxProviderMapKey).to(massagedProviderMapKey); Provider<Map<K, Provider<V>>> mapProvider = binder.getProvider(providerMapKey); binder.bind(mapKey).toProvider(new RealMapProvider(dependencies, mapProvider)); }
Key<V> getKeyForNewValue(K key) { checkNotNull(key, "key"); checkConfiguration(!isInitialized(), "MapBinder was already initialized"); Key<V> valueKey = Key.get(valueType, new RealElement(entrySetBinder.getSetName(), MAPBINDER, keyType.toString())); entrySetBinder.addBinding().toProvider(new ProviderMapEntry<K, V>( key, binder.getProvider(valueKey), valueKey)); return valueKey; }
public void configure(Binder binder) { checkConfiguration(!isInitialized(), "MapBinder was already initialized");