| /* |
| * Copyright (C) 2014 The Dagger Authors. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package dagger.internal; |
| |
| import static dagger.internal.DaggerCollections.newLinkedHashMapWithExpectedSize; |
| import static dagger.internal.Preconditions.checkNotNull; |
| import static java.util.Collections.unmodifiableMap; |
| |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import javax.inject.Provider; |
| |
| /** |
| * An {@code abstract} {@link Factory} implementation used to implement {@link Map} bindings. |
| * |
| * @param <K> the key type of the map that this provides |
| * @param <V> the type that each contributing factory |
| * @param <V2> the value type of the map that this provides |
| */ |
| abstract class AbstractMapFactory<K, V, V2> implements Factory<Map<K, V2>> { |
| private final Map<K, Provider<V>> contributingMap; |
| |
| AbstractMapFactory(Map<K, Provider<V>> map) { |
| this.contributingMap = unmodifiableMap(map); |
| } |
| |
| /** The map of {@link Provider}s that contribute to this map binding. */ |
| final Map<K, Provider<V>> contributingMap() { |
| return contributingMap; |
| } |
| |
| /** A builder for {@link AbstractMapFactory}. */ |
| public abstract static class Builder<K, V, V2> { |
| final LinkedHashMap<K, Provider<V>> map; |
| |
| Builder(int size) { |
| this.map = newLinkedHashMapWithExpectedSize(size); |
| } |
| |
| // Unfortunately, we cannot return a self-type here because a raw Provider type passed to one of |
| // these methods affects the returned type of the method. The first put*() call erases the self |
| // type to the "raw" self type, and the second erases the type to the upper bound |
| // (AbstractMapFactory.Builder), which doesn't have a build() method. |
| // |
| // The methods are therefore not declared public so that each subtype will redeclare them and |
| // expand their accessibility |
| |
| /** Associates {@code key} with {@code providerOfValue}. */ |
| Builder<K, V, V2> put(K key, Provider<V> providerOfValue) { |
| map.put(checkNotNull(key, "key"), checkNotNull(providerOfValue, "provider")); |
| return this; |
| } |
| |
| Builder<K, V, V2> putAll(Provider<Map<K, V2>> mapOfProviders) { |
| if (mapOfProviders instanceof DelegateFactory) { |
| @SuppressWarnings("unchecked") |
| DelegateFactory<Map<K, V2>> asDelegateFactory = (DelegateFactory) mapOfProviders; |
| return putAll(asDelegateFactory.getDelegate()); |
| } |
| @SuppressWarnings("unchecked") |
| AbstractMapFactory<K, V, ?> asAbstractMapFactory = |
| ((AbstractMapFactory<K, V, ?>) (Provider) mapOfProviders); |
| map.putAll(asAbstractMapFactory.contributingMap); |
| return this; |
| } |
| } |
| } |