public class MavenSettingsMerger {

    /**
     * @param dominant
     * @param recessive
     * @param recessiveSourceLevel
     */
    public void merge(Settings dominant, Settings recessive, String recessiveSourceLevel) {
        if (dominant == null || recessive == null) {
            return;
        }

        recessive.setSourceLevel(recessiveSourceLevel);

public class MavenToolchainMerger {

    public void merge(PersistedToolchains dominant, PersistedToolchains recessive, String recessiveSourceLevel) {
        if (dominant == null || recessive == null) {
            return;
        }

        recessive.setSourceLevel(recessiveSourceLevel);

        shallowMerge(dominant.getToolchains(), recessive.getToolchains(), recessiveSourceLevel);
    }

    private void shallowMerge(

    public static XmlNode merge(XmlNode dominant, XmlNode recessive) {
        return merge(dominant, recessive, null);
    }

    /**
     * Merges two XML nodes.
     */
    @Nullable
    public static XmlNode merge(
            @Nullable XmlNode dominant, @Nullable XmlNode recessive, @Nullable Boolean childMergeOverride) {
        return getService().doMerge(dominant, recessive, childMergeOverride);
    }

    /**

    @Nullable
    static XmlNode merge(@Nullable XmlNode dominant, @Nullable XmlNode recessive) {
        return XmlService.merge(dominant, recessive, null);
    }

    @Nullable
    static XmlNode merge(
            @Nullable XmlNode dominant, @Nullable XmlNode recessive, @Nullable Boolean childMergeOverride) {
        return XmlService.merge(dominant, recessive, childMergeOverride);
    }

    /**

                InputStream isRecessive = MavenToolchainMergerTest.class.getResourceAsStream("toolchains-jdks.xml")) {
            PersistedToolchains dominant = read(isDominant);
            PersistedToolchains recessive = read(isRecessive);
            assertEquals(2, dominant.getToolchains().size());

            merger.merge(dominant, recessive, TrackableBase.USER_LEVEL);

            }
        }

        metadata.getVersioning().setSnapshotVersions(new ArrayList<>(versions.values()));

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {
            metadata.setPlugins(new ArrayList<>(recessive.getPlugins()));
        }
    }

    private static int getBuildNumber(Metadata metadata) {
        int number = 0;

            List<Repository> dominant, recessive;
            if (sourceDominant) {
                dominant = src;
                recessive = tgt;
            } else {
                dominant = tgt;
                recessive = src;
            }

            for (Repository element : dominant) {

        Metadata recessive = read(existing);

        merge(recessive);

        write(result, metadata);

        merged = true;
    }

    @Override
    public boolean isMerged() {
        return merged;
    }

    protected abstract void merge(Metadata recessive);

    static Metadata read(Path metadataPath) throws RepositoryException {

        return metadata;
    }

    @Override
    protected void merge(Metadata recessive) {
        Versioning versioning = metadata.getVersioning();
        versioning.setLastUpdatedTimestamp(timestamp);

        if (recessive.getVersioning() != null) {
            if (versioning.getLatest() == null) {
                versioning.setLatest(recessive.getVersioning().getLatest());
            }

        plugin.setName(pluginInfo.name);
        result.getPlugins().add(plugin);
        return result;
    }

    @Override
    protected void merge(Metadata recessive) {
        List<Plugin> recessivePlugins = recessive.getPlugins();
        List<Plugin> plugins = metadata.getPlugins();
        if (!recessivePlugins.isEmpty() || !plugins.isEmpty()) {