org.apache.ivy.plugins.conflict.ConflictManager Java Examples

public synchronized ConflictManager getConflictManager(ModuleId moduleId) {
    ModuleSettings ms = moduleSettings.getRule(moduleId, new Filter<ModuleSettings>() {
        public boolean accept(ModuleSettings o) {
            return o.getConflictManager() != null;
        }
    });
    if (ms == null) {
        return getDefaultConflictManager();
    } else {
        ConflictManager cm = getConflictManager(ms.getConflictManager());
        if (cm == null) {
            throw new IllegalStateException("ivy badly configured: unknown conflict manager "
                    + ms.getConflictManager());
        }
        return cm;
    }
}
 

void addConflict(DefaultModuleDescriptor md, IvySettings settings) {
    String matcherName = (matcher == null) ? PatternMatcher.EXACT : matcher;
    String orgPattern = (org == null) ? PatternMatcher.ANY_EXPRESSION : org;
    String modulePattern = (module == null) ? PatternMatcher.ANY_EXPRESSION : module;
    ConflictManager cm = null;
    if (rev != null) {
        cm = new FixedConflictManager(splitToArray(rev));
    } else if (manager != null) {
        cm = settings.getConflictManager(manager);
    }
    md.addConflictManager(new ModuleId(orgPattern, modulePattern),
        settings.getMatcher(matcherName), cm);
}
 

protected void managerStarted(Attributes attributes, String managerAtt) {
    String org = settings.substitute(attributes.getValue("org"));
    if (org == null) {
        org = PatternMatcher.ANY_EXPRESSION;
    }
    String mod = settings.substitute(attributes.getValue("module"));
    if (mod == null) {
        mod = PatternMatcher.ANY_EXPRESSION;
    }
    ConflictManager cm;
    String name = settings.substitute(attributes.getValue(managerAtt));
    String rev = settings.substitute(attributes.getValue("rev"));
    if (rev != null) {
        cm = new FixedConflictManager(splitToArray(rev));
    } else if (name != null) {
        cm = settings.getConflictManager(name);
        if (cm == null) {
            addError("unknown conflict manager: " + name);
            return;
        }
    } else {
        addError("bad conflict manager: no manager nor rev");
        return;
    }
    String matcherName = settings.substitute(attributes.getValue("matcher"));
    PatternMatcher matcher = (matcherName == null) ? defaultMatcher
            : settings.getMatcher(matcherName);
    if (matcher == null) {
        addError("unknown matcher: " + matcherName);
        return;
    }
    getMd().addConflictManager(new ModuleId(org, mod), matcher, cm);
}
 

private Collection<IvyNode> resolveConflicts(VisitNode node, VisitNode ancestor,
        Collection<IvyNode> conflicts, ConflictManager conflictManager) {
    if (node.getParent() != ancestor
    // we are not handling the direct parent

            && conflictManager == settings.getConflictManager(node.getModuleId())
            // the conflict manager is the default one

            && node.getParent().getNode()
                    .getResolvedNodes(node.getModuleId(), node.getRootModuleConf())
                    .equals(conflicts)
    // there is no new conflict in this ancestor

    ) {
        // IVY-465 case
        if (settings.debugConflictResolution()) {
            Message.debug("no new conflicting revisions for " + node + " in " + ancestor + ": "
                    + conflicts);
        }

        return conflicts;
    } else {
        if (settings.debugConflictResolution()) {
            Message.debug("found conflicting revisions for " + node + " in " + ancestor + ": "
                    + conflicts);
        }

        return conflictManager.resolveConflicts(ancestor.getNode(), conflicts);
    }
}
 

public Collection<ConflictManager> getAllEvictingConflictManagers() {
    Collection<ConflictManager> ret = new HashSet<>();
    for (EvictionData ed : evicted.values()) {
        ret.add(ed.getConflictManager());
    }
    return ret;
}
 

public ConflictManager getConflictManager(ModuleId mid) {
    if (md == null) {
        throw new IllegalStateException(
                "impossible to get conflict manager when data has not been loaded. IvyNode = "
                        + this);
    }
    ConflictManager cm = md.getConflictManager(mid);
    return cm == null ? settings.getConflictManager(mid) : cm;
}
 

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

public ConflictManager getConflictManager(String name) {
    return AbstractResolver.this.getSettings().getConflictManager(name);
}
 

public synchronized void setDefaultConflictManager(ConflictManager defaultConflictManager) {
    this.defaultConflictManager = defaultConflictManager;
}
 

public synchronized void addConflictManager(String name, ConflictManager cm) {
    init(cm);
    conflictsManager.put(name, cm);
}
 

public synchronized ConflictManager getConflictManager(String name) {
    if ("default".equals(name)) {
        return getDefaultConflictManager();
    }
    return conflictsManager.get(name);
}
 

public synchronized void addConfigured(ConflictManager cm) {
    addConflictManager(cm.getName(), cm);
}
 

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

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

public ConflictManager getConflictManager(ModuleId moduleId) {
    return conflictManagers.getRule(moduleId);
}
 

public void markEvicted(String rootModuleConf, IvyNode node, ConflictManager conflictManager,
        Collection<IvyNode> resolved) {
    EvictionData evictionData = new EvictionData(rootModuleConf, node, conflictManager,
            resolved);
    markEvicted(evictionData);
}
 

public Collection<ConflictManager> getAllEvictingConflictManagers() {
    return eviction.getAllEvictingConflictManagers();
}
 

public ConflictManager getConflictManager() {
    return conflictManager;
}
 

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

/**
 * Creates a new object containing the eviction data of an {@link IvyNode}.
 *
 * @param rootModuleConf
 *            the root module configuration
 * @param parent
 *            the parent node (or <tt>null</tt> in case of transitive eviction)
 * @param conflictManager
 *            the conflict manager which evicted the node (or <tt>null</tt> in case of
 *            transitive eviction)
 * @param selected
 *            a collection of {@link IvyNode}s which evict the evicted node (or
 *            <tt>null</tt> in case of transitive eviction)
 * @param detail
 *            a String detailing the reason why the node was evicted
 */
public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
        Collection<IvyNode> selected, String detail) {
    this.rootModuleConf = rootModuleConf;
    this.parent = parent;
    this.conflictManager = conflictManager;
    this.selected = selected;
    this.detail = detail;
}
 

/**
 * @param id ModuleId
 * @return the conflict manager to use for the given ModuleId, or null if no specific conflict
 *         manager is associated with the given module id in this module descriptor.
 */
ConflictManager getConflictManager(ModuleId id);
 

/**
 * regular expressions as explained in Pattern class may be used in ModuleId organisation and
 * name
 *
 * @param moduleId ditto
 * @param matcher PatternMatcher
 * @param manager ConflictManager
 */
public void addConflictManager(ModuleId moduleId, PatternMatcher matcher,
        ConflictManager manager) {
    conflictManagers.defineRule(new MapMatcher(moduleId.getAttributes(), matcher), manager);
}
 

/**
 * Creates a new object containing the eviction data of an {@link IvyNode}.
 *
 * @param rootModuleConf
 *            the root module configuration
 * @param parent
 *            the parent node (or <tt>null</tt> in case of transitive eviction)
 * @param conflictManager
 *            the conflict manager which evicted the node (or <tt>null</tt> in case of
 *            transitive eviction)
 * @param selected
 *            a collection of {@link IvyNode}s which evict the evicted node (or
 *            <tt>null</tt> in case of transitive eviction)
 */
public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
        Collection<IvyNode> selected) {
    this(rootModuleConf, parent, conflictManager, selected, null);
}
 

/**
 * Marks the current node as evicted by the the given selected IvyNodes, in the given parent and
 * root module configuration, with the given {@link ConflictManager}
 *
 * @param parent
 *            the VisitNode in which eviction has been made
 * @param conflictMgr
 *            the conflict manager responsible for the eviction
 * @param selected
 *            a Collection of {@link IvyNode} which have been selected
 */
public void markEvicted(VisitNode parent, ConflictManager conflictMgr,
        Collection<IvyNode> selected) {
    node.markEvicted(rootModuleConf, parent.getNode(), conflictMgr, selected);
}
 

ConflictManager getConflictManager(ModuleId mid); 

ConflictManager getConflictManager(String name);