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

Go to download
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.util.concurrent.MoreExecutors.directExecutor;

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 AbstractMapProducer {
  private MapProducer(ImmutableMap> contributingMap) {
    super(contributingMap);
  }

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

  /** A builder for {@link MapProducer} */
  public static final class Builder extends AbstractMapProducer.Builder {
    private Builder(int size) {
      super(size);
    }

    @Override
    public Builder put(K key, Producer producerOfValue) {
      super.put(key, producerOfValue);
      return this;
    }

    @Override
    public Builder put(K key, Provider providerOfValue) {
      super.put(key, providerOfValue);
      return this;
    }

    @Override
    public Builder putAll(Producer> mapProducer) {
      super.putAll(mapProducer);
      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 : contributingMap().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());
  }
}