}

    @Override
    public boolean containsValue(Object value) {
        return delegate.get().containsValue(value);
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        return new EntrySet();
    }

    @Override
    @Nullable
    public V put(K key, V value) {
        V oldValue = get(key);
        delegate.put(key, value);
        return oldValue;
    }

                estimatedExperimentDurations.entrySet().stream()
                    .collect(Collectors.groupingBy(
                        it -> it.getKey().getPerformanceExperiment().getScenario(),
                        LinkedHashMap::new,
                        Collectors.toList())
                    );
            List<PerformanceScenarioDurations> json = performanceScenarioMap.entrySet().stream()
                .map(entry -> {

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public Spliterator<V> spliterator() {
    return CollectSpliterators.map(map.entrySet().spliterator(), Entry::getValue);
  }

            if (added.endsWith(PACKAGE_INFO)) {
                changed.add(added);
            }
        }
        for (Map.Entry<String, HashCode> removedOrChanged : Sets.difference(other.classHashes.entrySet(), classHashes.entrySet())) {
            DependentsSet dependents = getDependents(removedOrChanged.getKey());
            if (dependents.isDependencyToAll()) {
                return dependents;
            }

        for (Map.Entry<String, LifecyclePhase> e : lphases.entrySet()) {
            phases.put(e.getKey(), e.getValue().toString());
        }
        return phases;
    }

    @Deprecated
    public void setPhases(Map<String, String> phases) {
        Map<String, LifecyclePhase> lphases = new LinkedHashMap<>();
        for (Map.Entry<String, String> e : phases.entrySet()) {

    assertThat(diff1.entriesOnlyOnLeft().entrySet())
        .containsExactly(Maps.immutableEntry(4, "d"), Maps.immutableEntry(2, "b"))
        .inOrder();
    assertThat(diff1.entriesOnlyOnRight().entrySet()).contains(Maps.immutableEntry(6, "z"));
    assertThat(diff1.entriesInCommon().entrySet()).contains(Maps.immutableEntry(1, "a"));
    assertThat(diff1.entriesDiffering().entrySet())
        .containsExactly(

        return propertiesFileFilters.entrySet().stream()
            .anyMatch(entry -> entry.getKey().matches(relativePathSegments.get(), 0));
    }

    @Nullable
    private ResourceEntryFilter matchingFiltersFor(Supplier<String[]> relativePathSegments) {
        List<ResourceEntryFilter> matchingFilters = propertiesFileFilters.entrySet().stream()

                int idx = 0;
                for (Map.Entry<K, V> e : map.entrySet()) {
                    entries[idx++] = new SimpleImmutableEntry<>(e.getKey(), e.getValue());
                }
            } else {
                entries = new Object[0];
            }
        }

        @Override
        public Set<Entry<K, V>> entrySet() {
            return new AbstractImmutableSet<Entry<K, V>>() {

    public Collection<Object> values() {
        return parent.values();
    }

    @Override
    public Set<java.util.Map.Entry<String, Object>> entrySet() {
        if (parent.containsKey(LANG_KEY)) {
            final List<java.util.Map.Entry<String, Object>> list = new ArrayList<>(parent.entrySet());
            Collections.sort(list, (o1, o2) -> {
                final String k1 = o1.getKey();
                if (LANG_KEY.equals(k1)) {

  }

  @Override
  UnmodifiableIterator<Entry<K, V>> entryIterator() {
    return Maps.unmodifiableEntryIterator(delegate.entrySet().iterator());
  }

  @Override
  Spliterator<Entry<K, V>> entrySpliterator() {
    return CollectSpliterators.map(delegate.entrySet().spliterator(), Maps::unmodifiableEntry);
  }

  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {