static <V extends @Nullable Object> V getDoneValue(Object obj) throws ExecutionException {
    // While this seems like it might be too branch-y, simple benchmarking proves it to be
    // unmeasurable (comparing done AbstractFutures with immediateFuture)
    if (obj instanceof Cancellation) {
      Cancellation cancellation = (Cancellation) obj;
      Throwable cause = cancellation.cause;

        return lifecyclesMap.values().stream()
                .peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))
                .sorted(Comparator.comparing(Lifecycle::getId, comparator))
                .collect(Collectors.toList());
    }

    private Map<String, Lifecycle> lookupLifecycles() {
        // TODO: Remove the following code when maven-compat is gone

                    include = false;
                }
            }
            if (include) {
                Map<PhaseId, List<MojoExecution>> phaseBindings = new TreeMap<>(
                        Comparator.comparing(PhaseId::toString, new PhaseComparator(lifecycle.getPhases())));
                mappings.put(phase, phaseBindings);
            }
        }

        /*

            for (final File file : jarFiles) {
                list.add(getArtifactFromFileName(artifactType, file.getName()));
            }
            list.sort(Comparator.comparing(Artifact::getName));
            return list.toArray(new Artifact[list.size()]);
        }

        final File[] jarFiles = ResourceUtil.getPluginJarFiles(artifactType.getId());

  public void testWhere() {
    assertEquals(new TypeToken<Map<String, Integer>>() {}, mapOf(String.class, Integer.class));
    // Type inference is doomed here: int.class is the same as Integer.class, so this is comparing
    // TypeToken<int[]> and TypeToken<Integer[]>.
    assertEquals(new TypeToken<int[]>() {}, arrayOf(int.class));
    assertEquals(int[].class, arrayOf(int.class).getRawType());
  }

  @Keep

        valueMap.put("action", action.replace('\t', '_').toUpperCase(Locale.ENGLISH));
        valueMap.put("user", user.map(FessUserBean::getUserId).orElse("-"));
        final Comparator<Map.Entry<String, String>> c = Comparator.comparing(Map.Entry::getKey);
        params.entrySet().stream().sorted(c).forEach(e -> {
            valueMap.put(e.getKey(), e.getValue().replace('\t', '_'));
        });
        log(valueMap);
    }

    /**

  final Segment<K, V>[] segments;

  /** The concurrency level. */
  final int concurrencyLevel;

  /** Strategy for comparing keys. */
  final Equivalence<Object> keyEquivalence;

  /** Strategy for comparing values. */
  final Equivalence<Object> valueEquivalence;

  /** Strategy for referencing keys. */
  final Strength keyStrength;

  public void testWhere() {
    assertEquals(new TypeToken<Map<String, Integer>>() {}, mapOf(String.class, Integer.class));
    // Type inference is doomed here: int.class is the same as Integer.class, so this is comparing
    // TypeToken<int[]> and TypeToken<Integer[]>.
    assertEquals(new TypeToken<int[]>() {}, arrayOf(int.class));
    assertEquals(int[].class, arrayOf(int.class).getRawType());
  }

  @Keep

  final Segment<K, V>[] segments;

  /** The concurrency level. */
  final int concurrencyLevel;

  /** Strategy for comparing keys. */
  final Equivalence<Object> keyEquivalence;

  /** Strategy for comparing values. */
  final Equivalence<Object> valueEquivalence;

  /** Strategy for referencing keys. */
  final Strength keyStrength;

  /** The segments, each of which is a specialized hash table. */
  final transient Segment<K, V, E, S>[] segments;

  /** The concurrency level. */
  final int concurrencyLevel;

  /** Strategy for comparing keys. */
  final Equivalence<Object> keyEquivalence;

  /** Strategy for handling entries and segments in a type-safe and efficient manner. */
  final transient InternalEntryHelper<K, V, E, S> entryHelper;

  /**