package com.google.common.util.concurrent;

import static com.google.common.util.concurrent.Futures.transform;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;

import com.google.common.base.Function;
import java.lang.reflect.UndeclaredThrowableException;

/**
 * Unit tests for {@link Futures#transform(ListenableFuture, Function, Executor)}.
 *
 * @author Nishant Thakkar
 */

        return ImmutableMap.copyOf(sourceMap);
      }
    },
    COPY_OF_ENTRIES {
      @Override
      public Map<Object, Object> create(List<?> keys) {
        return ImmutableMap.copyOf(
            Lists.transform(keys, k -> Maps.immutableEntry(k, "dummy value")));
      }
    },
    BUILDER_PUT_ONE_BY_ONE {
      @Override
      public Map<Object, Object> create(List<?> keys) {

  @Override
  @CheckForNull
  public T orNull() {
    return null;
  }

  @Override
  public Set<T> asSet() {
    return Collections.emptySet();
  }

  @Override
  public <V> Optional<V> transform(Function<? super T, V> function) {
    checkNotNull(function);
    return Optional.absent();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this;
  }

  @Override
  @CheckForNull
  public T orNull() {
    return null;
  }

  @Override
  public Set<T> asSet() {
    return Collections.emptySet();
  }

  @Override
  public <V> Optional<V> transform(Function<? super T, V> function) {
    checkNotNull(function);
    return Optional.absent();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this;
  }

    }
    Set<List<Optional<?>>> cartesianProduct = Sets.cartesianProduct(optionalSets);
    return Iterables.transform(
        cartesianProduct,
        new Function<List<Optional<?>>, List<Object>>() {
          @Override
          public List<Object> apply(List<Optional<?>> objs) {
            return Lists.transform(objs, OPTIONAL_TO_NULLABLE);
          }
        });
  }

package com.google.common.util.concurrent;

import static com.google.common.util.concurrent.Futures.transform;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;

import com.google.common.base.Function;
import java.lang.reflect.UndeclaredThrowableException;

/**
 * Unit tests for {@link Futures#transform(ListenableFuture, Function, Executor)}.
 *
 * @author Nishant Thakkar
 */

  }

  @Override
  public Set<N> successors() {
    return adjacentNodes();
  }

  @Override
  public Iterator<EndpointPair<N>> incidentEdgeIterator(N thisNode) {
    return Iterators.transform(
        adjacentNodeValues.keySet().iterator(),
        (N incidentNode) -> EndpointPair.unordered(thisNode, incidentNode));
  }

  @Override
  @CheckForNull
  public V value(N node) {

    assertThat(f.get()).isEqualTo(CustomRuntimeException.class);
  }

  public void testTransform() throws Exception {
    FluentFuture<Integer> f =
        FluentFuture.from(immediateFuture(1))
            .transform(
                new Function<Integer, Integer>() {
                  @Override
                  public Integer apply(Integer input) {
                    return input + 1;
                  }
                },

    }
    Set<List<Optional<?>>> cartesianProduct = Sets.cartesianProduct(optionalSets);
    return Iterables.transform(
        cartesianProduct,
        new Function<List<Optional<?>>, List<Object>>() {
          @Override
          public List<Object> apply(List<Optional<?>> objs) {
            return Lists.transform(objs, OPTIONAL_TO_NULLABLE);
          }
        });
  }

 * asynchronous operations. You can chain them together manually with calls to methods like {@link
 * Futures#transform(ListenableFuture, com.google.common.base.Function, Executor) Futures.transform}
 * (or {@link FluentFuture#transform(com.google.common.base.Function, Executor)
 * FluentFuture.transform}), but you will often find it easier to use a framework. Frameworks