src/java/org/apache/ivy/core/cache/ParserSettingsMonitor.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */
package org.apache.ivy.core.cache;

import java.io.File;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.ivy.core.RelativeUrlResolver;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.core.module.status.StatusManager;
import org.apache.ivy.core.settings.TimeoutConstraint;
import org.apache.ivy.plugins.conflict.ConflictManager;
import org.apache.ivy.plugins.matcher.PatternMatcher;
import org.apache.ivy.plugins.namespace.Namespace;
import org.apache.ivy.plugins.parser.ParserSettings;
import org.apache.ivy.plugins.resolver.DependencyResolver;
import org.apache.ivy.util.Message;

/**
 * Keep traces of the usage of a ParserSettings in order to check afterwards that the relevant
 * settings didn't changed.
 * <p>
 * A ParserSettingsMonitor provide a ParserSettings that must be used in place of the original one.
 * </p>
 * <p>
 * The current implementation consider that a settings changed iff one of the used variable has
 * changed.
 * </p>
 */
class ParserSettingsMonitor {

    private ParserSettings delegatedSettings;

    private final Map<String, String> substitutes;

    public ParserSettingsMonitor(ParserSettings settings) {
        this.delegatedSettings = settings;
        this.substitutes = new HashMap<>();
    }

    /**
     * @return The parser settings that must be used in place of the original settings The returned
     *         object delegates all the call to the original settings.
     */
    public ParserSettings getMonitoredSettings() {
        return monitoredSettings;
    }

    /**
     * Free the resource used during the monitoring, keeping only the info required to evaluate
     * hasChanged.
     */
    public void endMonitoring() {
        monitoredSettings = null;
        delegatedSettings = null;
    }

    /**
     * Check if the newSettings is compatible with the original settings that has been monitored.
     * Only the info that was actually used is compared.
     */
    public boolean hasChanged(ParserSettings newSettings) {
        for (Map.Entry<String, String> entry : substitutes.entrySet()) {
            String key = entry.getKey();
            if (!entry.getValue().equals(newSettings.substitute(key))) {
                Message.debug("settings variable has changed for : " + key);
                return true;
            }
        }
        return false;
    }

    private ParserSettings monitoredSettings = new ParserSettings() {

        public ConflictManager getConflictManager(String name) {
            return delegatedSettings.getConflictManager(name);
        }

        public PatternMatcher getMatcher(String matcherName) {
            return delegatedSettings.getMatcher(matcherName);
        }

        public Namespace getNamespace(String namespace) {
            return delegatedSettings.getNamespace(namespace);
        }

        public RelativeUrlResolver getRelativeUrlResolver() {
            return delegatedSettings.getRelativeUrlResolver();
        }

        public ResolutionCacheManager getResolutionCacheManager() {
            return delegatedSettings.getResolutionCacheManager();
        }

        public DependencyResolver getResolver(ModuleRevisionId mRevId) {
            return delegatedSettings.getResolver(mRevId);
        }

        public StatusManager getStatusManager() {
            return delegatedSettings.getStatusManager();
        }

        public File resolveFile(String filename) {
            return delegatedSettings.resolveFile(filename);
        }

        public String getDefaultBranch(ModuleId moduleId) {
            return delegatedSettings.getDefaultBranch(moduleId);
        }

        public Namespace getContextNamespace() {
            return delegatedSettings.getContextNamespace();
        }

        public Map<String, String> substitute(Map<String, String> strings) {
            Map<String, String> substituted = new LinkedHashMap<>();
            for (Map.Entry<String, String> entry : strings.entrySet()) {
                substituted.put(entry.getKey(), substitute(entry.getValue()));
            }
            return substituted;
        }

        public String substitute(String value) {
            String r = delegatedSettings.substitute(value);
            if (value != null && !value.equals(r)) {
                substitutes.put(value, r);
            }
            return r;
        }

        public String getVariable(String value) {
            return delegatedSettings.getVariable(value);
        }

        @Override
        public TimeoutConstraint getTimeoutConstraint(final String name) {
            return delegatedSettings.getTimeoutConstraint(name);
        }
    };
}