changedClasses.forEach(generatedTypesByOrigin::remove);
        generatedTypesByOrigin.putAll(newData.getGeneratedTypesByOrigin());
        Map<String, Set<GeneratedResource>> generatedResourcesByOrigin = new HashMap<>(oldData.getGeneratedResourcesByOrigin());
        changedClasses.forEach(generatedResourcesByOrigin::remove);
        generatedResourcesByOrigin.putAll(newData.getGeneratedResourcesByOrigin());

        return new AnnotationProcessingData(

                contributor.contribute(userPropertiesMap);
            }
            Properties newProperties = new Properties();
            newProperties.putAll(userPropertiesMap);
            mavenExecutionRequest.setUserProperties(newProperties);
        }
    }

        Map<String, String> mergedProps = new HashMap<>();
        mergedProps.putAll(getPropertiesFromRequestedProfiles(request));
        mergedProps.putAll(new HashMap<String, String>((Map) request.getSystemProperties()));
        mergedProps.putAll(new HashMap<String, String>((Map) request.getUserProperties()));
        return mergedProps;
    }

        HashMap<String, String> result = new HashMap<>(getSystemProperties());
        if (project != null) {
            result.putAll(project.getModel().getProperties());
        }
        result.putAll(getUserProperties());
        return result;
    }

    @Nonnull
    @Override
    public Version getMavenVersion() {

 * the methods of the delegate. For example, overriding {@link #put} alone <i>will not</i> change
 * the behavior of {@link #putAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *

        def dir = temporaryFolder.getTestDirectory()

        Map<String, Object> properties = new HashMap<String, Object>()
        properties.putAll(this.properties)
        properties.putAll(extraProps)

 * ManagedVersionMap
 */
@Deprecated
public class ManagedVersionMap extends HashMap<String, Artifact> {
    public ManagedVersionMap(Map<String, Artifact> map) {
        super();
        if (map != null) {
            putAll(map);
        }
    }

    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();

        private DefaultGeneralDataBuilder() {
        }

        private DefaultGeneralDataBuilder(GeneralData from) {
            mapBuilder.putAll(from.getAsMap());
        }

        @Override
        public GeneralDataSpec put(String key, String value) {
            mapBuilder.put(key, value);
            return this;
        }

        @Override

    return super.put(key, value);
  }

  @Override
  public void putAll(Map<? extends Class<? extends @NonNull B>, ? extends B> map) {
    Map<Class<? extends @NonNull B>, B> copy = new LinkedHashMap<>(map);
    for (Entry<? extends Class<? extends @NonNull B>, B> entry : copy.entrySet()) {
      cast(entry.getKey(), entry.getValue());
    }
    super.putAll(copy);
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull

        if (value != null) {
            return value;
        }
        return parent.remove(key);
    }

    @Override
    public void putAll(final Map<? extends K, ? extends V> m) {
        parent.putAll(m);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public Set<K> keySet() {
        // return original keys