*/
    String ID_COMBINATION_MODE_ATTRIBUTE = "combine.id";

    /**
     * In case of complex XML structures, combining can be done based on keys.
     * This is a comma separated list of attribute names.
     */
    String KEYS_COMBINATION_MODE_ATTRIBUTE = "combine.keys";

    /**
     * This default mode for combining a DOM node during merge means that where element names match, the process will

                for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
                    String key = "env."
                            + (caseSensitive ? entry.getKey() : entry.getKey().toUpperCase(Locale.ENGLISH));
                    tmp.setProperty(key, entry.getValue());
                }
                envVars = tmp;
            }

            props.putAll(envVars);
        }
    }

            this.realm = realm;
            this.extensionArtifactFilter = extensionArtifactFilter;
        }
    }

    Key createKey(List<? extends ClassRealm> extensionRealms);

    CacheRecord get(Key key);

    CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter);

    void flush();

    /**

        Key key = new CacheKey(
                project,
                project.getRemoteProjectRepositories(),
                scopesToCollect,
                scopesToResolve,
                aggregating,
                session);
        return keys.computeIfAbsent(key, k -> k);
    }

    @Override
    public CacheRecord get(Key key) throws LifecycleExecutionException {

                return true;
            } else {
                return obj != null && this.getClass().equals(obj.getClass()) && this.keys.equals(((Key) obj).keys);
            }
        }

        public int hashCode() {
            return this.keys.hashCode();
        }
    }

    /**
     * chains a collection of {@link WorkspaceReader}s

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.internal.impl.resolver.artifact;

/**
 * The keys for Maven specific properties of artifacts. These properties "extend" (or supplement) the Resolver
 * core properties defined in {@link org.eclipse.aether.artifact.ArtifactProperties}.
 *

     * @return Copy of the given properties.
     */
    public static Properties copyProperties(Properties properties) {
        final Properties copyProperties = new Properties();
        // guard against modification/removal of keys in the given properties (MNG-5670, MNG-6053, MNG-6105)
        synchronized (properties) {
            copyProperties.putAll(properties);
        }
        return copyProperties;
    }

 * {@code org.apache.maven.api.spi.PathScopeProvider}.
 * <p>
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *
 * @since 4.0.0
 * @see org.apache.maven.api.services.DependencyResolver
 * @see DependencyScope
 */
@Experimental
@Immutable
public interface PathScope extends ExtensibleEnum {

   |   plugins should document which type you must use.
   |
   | * provides: A list of key/value-pairs.
   |   Based on the toolchain-configuration in the pom.xml Maven will search for
   |   matching <provides/> configuration. You can decide for yourself which key-value
   |   pairs to use. Often used keys are 'version', 'vendor' and 'arch'. By default
   |   the version has a special meaning. If you configured in the pom.xml '1.5'

    private Map<Key, PluginDescriptor> descriptors = new ConcurrentHashMap<>(128);
    private Map<Key, Key> keys = new ConcurrentHashMap<>();

    public void flush() {
        descriptors.clear();
    }

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);