dagger.producers.internal.MapProducer Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of dagger-producers Show documentation
A fast dependency injector for Android and Java.
There is a newer version: 2.52
/*
 * Copyright (C) 2016 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.producers.internal;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
import static dagger.producers.internal.Producers.producerFromProvider;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import dagger.producers.Producer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.inject.Provider;

/**
 * A {@link Producer} implementation used to implement {@link Map} bindings. This producer returns a
 * {@code Map} which is populated by calls to the delegate {@link Producer#get} methods.
 */
public final class MapProducer extends AbstractProducer> {
  private final ImmutableMap> mapOfProducers;

  private MapProducer(ImmutableMap> mapOfProducers) {
    this.mapOfProducers = mapOfProducers;
  }

  /** Returns a new {@link Builder}. */
  public static  Builder builder() {
    return new Builder<>();
  }

  /** A builder for {@link MapProducer} */
  public static final class Builder {
    private final ImmutableMap.Builder> mapBuilder = ImmutableMap.builder();

    /** Associates {@code key} with {@code producerOfValue}. */
    public Builder put(K key, Producer producerOfValue) {
      checkNotNull(key, "key");
      checkNotNull(producerOfValue, "producer of value");
      mapBuilder.put(key, producerOfValue);
      return this;
    }

    /** Associates {@code key} with {@code providerOfValue}. */
    public Builder put(K key, Provider providerOfValue) {
      checkNotNull(key, "key");
      checkNotNull(providerOfValue, "provider of value");
      mapBuilder.put(key, producerFromProvider(providerOfValue));
      return this;
    }

    /** Returns a new {@link MapProducer}. */
    public MapProducer build() {
      return new MapProducer<>(mapBuilder.build());
    }
  }

  @Override
  protected ListenableFuture> compute() {
    final List>> listOfEntries = new ArrayList<>();
    for (final Entry> entry : mapOfProducers.entrySet()) {
      listOfEntries.add(
          Futures.transform(entry.getValue().get(), new Function>() {
            @Override
            public Entry apply(V computedValue) {
              return Maps.immutableEntry(entry.getKey(), computedValue);
            }
          }, directExecutor()));
    }

    return Futures.transform(
        Futures.allAsList(listOfEntries),
        new Function>, Map>() {
          @Override
          public Map apply(List> entries) {
            return ImmutableMap.copyOf(entries);
          }
        },
        directExecutor());
  }
}