import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

class PropertiesAsMap extends AbstractMap<String, String> {

    private final Map<Object, Object> properties;

    PropertiesAsMap(Map<Object, Object> properties) {
        this.properties = properties;
    }

    @Override
    public Set<Entry<String, String>> entrySet() {
        return new AbstractSet<Entry<String, String>>() {

                }
                if (key.getRawType() == List.class) {
                    Set<Binding<Object>> res2 = getBindings(key.getTypeParameter(0));
                    Set<Binding<Object>> res3 = res2 != null ? new HashSet<>(res2) : new HashSet<>();
                    try {
                        List<Object> l = containerProvider
                                .get()

        }
    }

    /**
     * Simply parse the given xml string.
     *
     * @param xml the input xml string
     * @return the parsed object
     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    public static Model fromXml(@Nonnull String xml) throws XmlReaderException {
        return new DefaultModelXmlFactory().fromXmlString(xml);
    }

                .build();
    }

    public void bind(Artifact artifact) {
        artifacts.add(artifact);
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId() + ':' + getVersion();
    }

    public static Object getKey(Artifact artifact) {
        return artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' + artifact.getBaseVersion();
    }

            } else {
                return compareTo(new DefaultVersion(versionScheme, o.asString()));
            }
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            metadata = metadata.withPlugins(new ArrayList<>(recessive.getPlugins()));
        }
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId();
    }

    public static Object getKey(Artifact artifact) {
        return artifact.getGroupId() + ':' + artifact.getArtifactId();
    }

    @Deprecated
    @Override

        Build build = model.getBuild();
        if (build != null) {
            List<Plugin> plugins = build.getPlugins();
            Map<Object, Plugin> normalized = new LinkedHashMap<>(plugins.size() * 2);

            for (Plugin plugin : plugins) {
                Object key = plugin.getKey();
                Plugin first = normalized.get(key);
                if (first != null) {

    public DependencyTraverser deriveChildTraverser(DependencyCollectionContext context) {
        requireNonNull(context, "context cannot be null");
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (null == obj || !getClass().equals(obj.getClass())) {
            return false;
        }
        return true;
    }

    @Override

            for (org.apache.maven.api.model.Dependency dependency : mgmt.getDependencies()) {
                result.addManagedDependency(convert(dependency, stereotypes));
            }
        }

        Map<String, Object> properties = new LinkedHashMap<>();

        Prerequisites prerequisites = model.getPrerequisites();
        if (prerequisites != null) {
            properties.put("prerequisites.maven", prerequisites.getMaven());
        }

            } else {
                cache = (ConcurrentHashMap<Object, Supplier<?>>)
                        repositoryCache.computeIfAbsent(session, KEY, ConcurrentHashMap::new);
            }
            return new DefaultModelCache(cache);
        }
    }

    private final ConcurrentMap<Object, Supplier<?>> cache;

    public DefaultModelCache() {
        this(new ConcurrentHashMap<>());
    }