ResolveOptions.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
 *
 *      http://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.resolve;

import java.util.Date;

import org.apache.ivy.core.LogOptions;
import org.apache.ivy.core.module.descriptor.Artifact;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.util.ConfigurationUtils;
import org.apache.ivy.util.filter.Filter;
import org.apache.ivy.util.filter.FilterHelper;

/**
 * A set of options used during resolve related tasks
 * 
 * @see ResolveEngine
 */
public class ResolveOptions extends LogOptions {

    /**
     * Default resolve mode, using default revision constraints in dependency descriptors.
     */
    public static final String RESOLVEMODE_DEFAULT = "default";

    /**
     * Dynamic resolve mode, using dynamic revision constraints in dependency descriptors.
     */
    public static final String RESOLVEMODE_DYNAMIC = "dynamic";

    /**
     * Array of all available resolve modes.
     */
    public static final String[] RESOLVEMODES = new String[] {RESOLVEMODE_DEFAULT,
            RESOLVEMODE_DYNAMIC};

    /**
     * an array of configuration names to resolve - must not be null nor empty
     */
    private String[] confs = new String[] {"*"};

    /**
     * the revision of the module for which dependencies should be resolved. This revision is
     * considered as the resolved revision of the module, unless it is null. If it is null, then a
     * default revision is given if necessary (no revision found in ivy file)
     */
    private String revision = null;

    /**
     * the date for which the dependencies should be resolved. All obtained artifacts should have a
     * publication date which is before or equal to the given date. The date can be null, in which
     * case all artifacts will be considered
     */
    private Date date = null;

    /**
     * True if validation of module descriptors should done, false otherwise
     */
    private boolean validate = true;

    /**
     * True if only the cache should be used for resolve, false if a real resolve with dependency
     * resolvers should be done
     */
    private boolean useCacheOnly = false;

    /**
     * True if the dependencies should be resolved transitively, false if only direct dependencies
     * should be resolved
     */
    private boolean transitive = true;

    /**
     * True if the resolve should also download artifacts, false if only dependency resolution with
     * module descriptors should be done
     */
    private boolean download = true;

    /**
     * True if a report of the resolve process should be output at the end of the process, false
     * otherwise
     */
    private boolean outputReport = true;

    /**
     * A filter to use to avoid downloading all artifacts.
     */
    private Filter<Artifact> artifactFilter = FilterHelper.NO_FILTER;

    /**
     * The resolve mode to use. Should be one of {@link #RESOLVEMODES}, or <code>null</code> to use
     * settings configured resolve mode.
     */
    private String resolveMode;

    /**
     * The id used to store the resolve information.
     */
    private String resolveId;

    private boolean refresh;

    /**
     * True if the resolve should compare the new resolution against the previous report
     **/
    private boolean checkIfChanged = false;

    public ResolveOptions() {
    }

    public ResolveOptions(ResolveOptions options) {
        super(options);
        confs = options.confs;
        revision = options.revision;
        date = options.date;
        validate = options.validate;
        refresh = options.refresh;
        useCacheOnly = options.useCacheOnly;
        transitive = options.transitive;
        download = options.download;
        outputReport = options.outputReport;
        resolveMode = options.resolveMode;
        artifactFilter = options.artifactFilter;
        resolveId = options.resolveId;
        checkIfChanged = options.checkIfChanged;
    }

    public Filter<Artifact> getArtifactFilter() {
        return artifactFilter;
    }

    public ResolveOptions setArtifactFilter(Filter<Artifact> artifactFilter) {
        this.artifactFilter = artifactFilter;
        return this;
    }

    /**
     * Returns the resolve mode to use, or <code>null</code> to use settings configured resolve
     * mode.
     * 
     * @return the resolve mode to use.
     */
    public String getResolveMode() {
        return resolveMode;
    }

    public ResolveOptions setResolveMode(String resolveMode) {
        this.resolveMode = resolveMode;
        return this;
    }

    /**
     * Indicates if the configurations use a special configuration * , *(private) or *(public). When
     * special configurations are used, you must have the module descriptor in order to get the list
     * of configurations.
     * 
     * @see #getConfs()
     * @see #getConfs(ModuleDescriptor)
     */
    public boolean useSpecialConfs() {
        for (int i = 0; confs != null && i < confs.length; i++) {
            if (confs[0].startsWith("*")) {
                return true;
            }
        }
        return false;
    }

    /**
     * @pre can only be called if useSpecialConfs()==false. When it is true, you have to provide a
     *      module desciptor so that configurations can be resolved.
     * @see #getConfs(ModuleDescriptor)
     */
    public String[] getConfs() {
        if (useSpecialConfs()) {
            throw new AssertionError("ResolveOptions.getConfs() "
                    + "can not be used for options used special confs.");
        }
        return confs;
    }

    /**
     * Get the aksed confs. Special confs (like *) use the moduleDescriptor to find the values *
     * 
     * @param md
     *            Used to get the exact values for special confs.
     * */
    public String[] getConfs(ModuleDescriptor md) {
        // TODO add isInline, in that case, replace * by *(public).
        return ConfigurationUtils.replaceWildcards(confs, md);
    }

    public ResolveOptions setConfs(String[] confs) {
        this.confs = confs;
        return this;
    }

    public Date getDate() {
        return date;
    }

    public ResolveOptions setDate(Date date) {
        this.date = date;
        return this;
    }

    public boolean isDownload() {
        return download;
    }

    public ResolveOptions setDownload(boolean download) {
        this.download = download;
        return this;
    }

    public boolean isOutputReport() {
        return outputReport;
    }

    public ResolveOptions setOutputReport(boolean outputReport) {
        this.outputReport = outputReport;
        return this;
    }

    public boolean isTransitive() {
        return transitive;
    }

    public ResolveOptions setTransitive(boolean transitive) {
        this.transitive = transitive;
        return this;
    }

    public boolean isUseCacheOnly() {
        return useCacheOnly;
    }

    public ResolveOptions setUseCacheOnly(boolean useCacheOnly) {
        this.useCacheOnly = useCacheOnly;
        return this;
    }

    public boolean isValidate() {
        return validate;
    }

    public ResolveOptions setValidate(boolean validate) {
        this.validate = validate;
        return this;
    }

    public String getRevision() {
        return revision;
    }

    public ResolveOptions setRevision(String revision) {
        this.revision = revision;
        return this;
    }

    public String getResolveId() {
        return resolveId;
    }

    public ResolveOptions setResolveId(String resolveId) {
        this.resolveId = resolveId;
        return this;
    }

    public ResolveOptions setRefresh(boolean refresh) {
        this.refresh = refresh;
        return this;
    }

    public boolean isRefresh() {
        return refresh;
    }

    public ResolveOptions setCheckIfChanged(boolean checkIfChanged) {
        this.checkIfChanged = checkIfChanged;
        return this;
    }

    public boolean getCheckIfChanged() {
        return checkIfChanged;
    }

    public static String getDefaultResolveId(ModuleDescriptor md) {
        ModuleId module = md.getModuleRevisionId().getModuleId();
        return getDefaultResolveId(module);
    }

    public static String getDefaultResolveId(ModuleId moduleId) {
        return moduleId.getOrganisation() + "-" + moduleId.getName();
    }

}