package de.matthias_burbach.deputy.core.project;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
  import java.util.Set;
  
  import de.matthias_burbach.deputy.core.rule.RuleSet;
  
  /***
   * Represents a Maven project object model (only the parts relevant for Deputy).
   *
   * @author Matthias Burbach
   */
  public class Project implements ProjectQualifier {
      /***
       * Whether this project is the root of the dependency graph currently
       * opened in Deputy. If so, it is the project which can be edited and
       * changed by rules to update and save its dependencies.
       */
      private boolean isRootProject = false;
  
      /***
       * Whether this project is an assembly or a component. By definition, an
       * assembly contains the recursive hull of all its dependencies in the
       * project.xml whereas a component does not.
       */
      private boolean isAssembly = false;
  
      /***
       * The group id of this project.
       */
      private String groupId;
  
      /***
       * The artifact id of this project.
       * <p/>
       * Is a mandatory property because many processings depend on it.<br/>
       * Some processings assume that the artifact id is sufficient and needs not
       * be complemented by the group id to uniquely identify the artifact.
       */
      private String artifactId;
  
      /***
       * The version of this project. Is a mandatory property because many
       * processings depend on it.
       */
      private String version;
  
      /***
       * The optional name of this project.
       */
      private String name;
  
      /***
       * The optional URL of this project's homepage.
       */
      private String url;
  
      /***
       * The type of this project. This is a non-standard element in the
       * project.xml. Its value is one of 'jar', 'war', ejb', 'dll'.<br/>
       * It is optional and defaults to 'jar'.
       */
      private String type;
  
      /***
       *  The name of jar file if it doesn't respect the
       *  &lt;artifactId&gt;-&lt;version&gt;.jar pattern.
       */
      private String jar;
  
      /***
       * The projects of type {@link Project} which depend on this project.
       */
      private List clients = new ArrayList();
  
      /***
       * The projects of type {@link Project} this project depends on
       * (literally as defined in the project.xml or
       * as a decision made by Deputy).
       */
      private List dependencies = new ArrayList();
  
      /***
       * The projects of type {@link Project} this project actually depends on
       * according to the literal entries in the project.xml, but which are
       * deprecated, i. e. overruled by a decision made by Deputy.
       */
      private List deprecatedDependencies = new ArrayList();
  
      /***
       * The non-top-level dependencies, i. e. dependencies of dependencies of
       * this project which are not direct dependencies of this project at the
       * same time.
      */
     private List indirectDependencies = null;
 
     /***
      * The version conflicts in the dependency graph that roots in this project.
      */
     private List conflicts;
 
     /***
      * The set of rules defined for this project. They are used by Deputy to
      * decide which version to take of which dependency in the dependency graph
      * that roots in this project.
      */
     private RuleSet ruleSet = new RuleSet();
 
     /***
      * The change listeners that need to be informed when this project changes
      * state.
      */
     private List changeListeners = new ArrayList();
 
     /***
      * Helps to sort projects in the dependency lists.
      */
     private ProjectComparator projectComparator = new ProjectComparator();
 
     /***
      * Maps artifactIds of type {@link java.lang.String} to lists of
      * XML property elements of type {@link org.jdom.Element} that were found as
      * child elements of the properties XML element of direct and indirect
      * dependencies defined in this project's POM file.
      * <p/>
      * These are re-written to the project.xml on save to preserve them. Note,
      * that properties will even be preserved if the version of the
      * corresponding dependency gets changed. This might not be appropriate
      * in all cases.
      * <p/>
      * The dependency property 'top' is excluded from these and treated in a
      * special way because it's a property defined by Deputy.
      */
     private Map dependencyProperties = new HashMap();
 
     /***
      * Maps dependencies of type {@link Project} to the corresponding
      * dependencies of type {@link ProjectQualifier}
      * that caused the dependency during the application of the rules.
      * If there is no mapping the project caused itself.
      */
     private Map dependencyCauses = new HashMap();
 
     /***
      * Maps clients of type {@link Project} to their literal dependencies
      * of type {@link ProjectQualifier} that caused the clientship during the
      * application of the rules.
      * If there is no mapping the project caused itself.
      */
     private Map clientCauses = new HashMap();
 
     /***
      * Maps clients of type {@link Project} to their literal dependencies
      * of type {@link ProjectQualifier} that caused the clientship during the
      * application of the rules.
      * If there is no mapping the project caused itself.
      *
      * @return The map described. Maybe empty but not <code>null</code>.
      */
     public Map getClientCauses() {
         return clientCauses;
     }
 
     /***
      * Maps dependencies of type {@link Project} to the corresponding
      * dependencies of type {@link ProjectQualifier}
      * that caused the dependency during the application of the rules.
      * If there is no mapping the project caused itself.
      *
      * @return The map described. Maybe empty but not <code>null</code>.
      */
     public Map getDependencyCauses() {
         return dependencyCauses;
     }
 
     /***
      * @return The group id of this project.
      */
     public String getGroupId() {
         return groupId;
     }
 
     /***
      * @param groupId The group id of this project.
      */
     public void setGroupId(final String groupId) {
         this.groupId = groupId;
     }
 
     /***
      * @return The artifact id of this project.
      */
     public String getArtifactId() {
         return artifactId;
     }
 
     /***
      * @param artifactId The artifact id of this project.
      */
     public void setArtifactId(final String artifactId) {
         this.artifactId = artifactId;
     }
 
     /***
      * @return The version of this project.
      */
     public String getVersion() {
         return version;
     }
 
     /***
      * @param version The version of this project.
      */
     public void setVersion(final String version) {
         this.version = version;
     }
 
     /***
      * @return The type of this project. This is a non-standard element in the
      *         project.xml. Its value is one of 'jar', 'war', ejb', 'dll'.
      *         It is optional and defaults to 'jar'.
      */
     public String getType() {
         return type;
     }
 
     /***
      * @param type The type of this project. This is a non-standard element in
      *             the project.xml. Its value is one of 'jar', 'war', ejb',
      *             'dll'. It is optional and defaults to 'jar'.
      */
     public void setType(final String type) {
         this.type = type;
     }
 
     /***
      * @return The name of jar file if it doesn't respect the
      *         &lt;artifactId&gt;-&lt;version&gt;.jar pattern.
      */
     public String getJar() {
         return jar;
     }
 
     /***
      * @param jar The name of jar file if it doesn't respect the
      *            &lt;artifactId&gt;-&lt;version&gt;.jar pattern.
      */
     public void setJar(final String jar) {
         this.jar = jar;
     }
 
     /***
      * @return Whether this project is the root of the dependency graph
      *         currently opened in Deputy. If so, it is the project which can be
      *         edited and changed by rules to update and save its dependencies.
      */
     public boolean isRootProject() {
         return isRootProject;
     }
 
     /***
      * @param rootProject Whether this project is the root of the dependency
      *                      graph currently opened in Deputy. If so, it is the
      *                      project which can be edited and changed by rules to
      *                      update and save its dependencies.
      */
     public void setRootProject(final boolean rootProject) {
         this.isRootProject = rootProject;
     }
 
     /***
      * @return The optional URL of this project's homepage.
      */
     public String getUrl() {
         return url;
     }
 
     /***
      * @return The default URL of this project's homepage.
      */
     public String getDefaultUrl() {
         String result = null;
         /*
          * Apply default logic to the URL, but only for VRP
          */
         if (artifactId.startsWith("vrp-")) {
             result = "http://bugz-e.tui.de/maven/vrp/projects/";
             if (getName().indexOf("assembly") == -1) {
                 result = result + "component.";
             }
             result = result + getName() + "/release-notes.html";
         }
         return result;
     }
 
     /***
      * @param url The optional URL of this project's homepage.
      */
     public void setUrl(final String url) {
         this.url = url;
     }
 
     /***
      * @return The optional name of this project
      *         (for display purposes and the like).
      */
     public String getName() {
         /*
          * Apply default and repair logic to the name, but only for VRP
          */
         if (name == null) {
             if (artifactId.startsWith("vrp-")) {
                 name = artifactId.substring("vrp-".length()); //default
             }
         }
         if (artifactId.startsWith("vrp-")) {
             name = name.replace('-', '.'); //repair
         }
         return name;
     }
 
     /***
      * @param name The optional name of this project
      *             (for display purposes and the like).
      */
     public void setName(final String name) {
         this.name = name;
     }
 
     /***
      * Tries to split off the numerical major version from the version.
      * The major version is defined to be the numerical prefix of the version
      * up to the first dot in the version or the whole version if it is an
      * integer without any dots.
      *
      * @return The major version part of the version string or <code>null</code>
      *         if parsing this fails.
      */
     public Integer getMajorVersion() {
         Integer result = null;
         String[] parts = version.split("//.");
         if (parts.length > 0) {
             try {
                 result = new Integer(Integer.parseInt(parts[0]));
             } catch (NumberFormatException e) {
                 // ignore
                 result = null;
             }
         }
         return result;
     }
 
     /***
      * Tries to split off the numerical minor version from the version between
      * the first and the second dot in the version string.
      * If the version is literally only a major version and nothing more,
      * the minor version defaults to 0.
      *
      * @return The minor version part of the version string or <code>null</code>
      *         if parsing this fails.
      */
     public Integer getMinorVersion() {
         if (getMajorVersion() != null) {
             if (getMajorVersion().toString().length() == version.length()) {
                 return new Integer(0);
             }
         }
         Integer result = null;
         String[] parts = version.split("//.");
         if (parts.length > 1) {
             try {
                 result = new Integer(Integer.parseInt(parts[1]));
             } catch (NumberFormatException e) {
                 // ignore
                 result = null;
             }
         }
         return result;
     }
 
     /***
      * Tries to split off the numerical micro version from the version after
      * the second dot in the version string. The micro version either extends up
      * to the third dot, if it exists, or up to the end of the version.<br/>
      * If the version is literally only a major version and nothing more, or a
      * major version, a dot and a minor version and nothing more,
      * the micro version defaults to 0.
      *
      * @return The micro version part of the version string or <code>null</code>
      *         if parsing this fails.
      */
     public Integer getMicroVersion() {
         if (getMajorVersion() != null) {
             if (getMajorVersion().toString().length() == version.length()) {
                 return new Integer(0);
             }
         }
         if (getMajorVersion() != null && getMinorVersion() != null) {
             if (getMajorVersion().toString().length()
                     + ".".length()
                     + getMinorVersion().toString().length()
                     == version.length()) {
                 return new Integer(0);
             }
         }
         Integer result = null;
         String[] parts = version.split("//.");
         if (parts.length > 2) {
             try {
                 result = new Integer(Integer.parseInt(parts[2]));
             } catch (NumberFormatException e) {
                 // ignore
                 result = null;
             }
         }
         return result;
     }
 
     /***
      * @return The rule set of this project.
      */
     public RuleSet getRuleSet() {
         return ruleSet;
     }
 
     /***
      * @param ruleSet The rule set of this project.
      */
     public void setRuleSet(final RuleSet ruleSet) {
         this.ruleSet = ruleSet;
     }
 
     /***
      * @return <code>true</code> whether this project is an assembly for which
      *         indirect dependencies need to be persisted in the project.xml.
      */
     public boolean isAssembly() {
         return isAssembly;
     }
 
     /***
      * @param assembly <code>true</code> whether this project is an assembly
      *                   for which indirect dependencies need to be persisted in
      *                   the project.xml.
      */
     public void setAssembly(final boolean assembly) {
         this.isAssembly = assembly;
     }
 
     /***
      * @param project The project to check.
      * @return <code>true</code> if this project has a dependency to the project
      *         passed in.
      */
     public boolean hasDependency(final Project project) {
         boolean result =
             projectOccursInProjectList(project, dependencies, true);
         return result;
     }
 
     /***
      * @param project The project to check.
      * @return <code>true</code> if this project has a dependency to the same
      *         artifact represented by the project passed in.
      */
     public boolean hasDependencyToSameArtifact(final Project project) {
         boolean result =
             projectOccursInProjectList(project, dependencies, false);
         return result;
     }
 
     /***
      * @param project Holds the artifact to find the dependency for.
      * @return The dependency with the same artifact id as the project passed in
      *         has or <code>null</code>.
      */
     public Project getDependencyToSameArtifact(final Project project) {
         Project result =
             getProjectFromProjectList(project, dependencies, false);
         return result;
     }
 
     /***
      * @return All direct dependencies of type {@link Project} of this project.
      */
     public Iterator getDependencies() {
         return dependencies.iterator();
     }
 
     /***
      * Adds a direct dependency to this project and notifies change listeners.
      *
      * @param dependency The dependency to add.
      */
     public void addDependency(final Project dependency) {
         dependencies.add(dependency);
         Collections.sort(dependencies, projectComparator);
         int index = dependencies.indexOf(dependency);
         fireAddedDependency(dependency, index);
     }
 
     /***
      * Removes a direct dependency from this project and notifies change
      * listeners.
      *
      * @param dependency The dependency to remove.
      */
     public void removeDependency(final Project dependency) {
         dependencies.remove(dependency);
         fireRemovedDependency(dependency);
     }
 
     /***
      * @param project The project to check if it is an indirect dependency.
      * @return <code>true</code> if the project passed in is an indirect
      *         dependency of this project.
      */
     public boolean hasIndirectDependency(final Project project) {
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         boolean result =
             projectOccursInProjectList(project, indirectDependencies, true);
         return result;
     }
 
     /***
      * @param project Holds the artifact to check the dependency for.
      * @return <code>true</code> if this project has an indirect dependency to
      *         the same artifact as the project passed in has.
      */
     public boolean hasIndirectDependencyToSameArtifact(final Project project) {
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         boolean result =
             projectOccursInProjectList(project, indirectDependencies, false);
         return result;
     }
 
     /***
      * @param project Holds the artifact to find the indirect dependency for.
      * @return The indirect dependency with the same artifact id as the project
      *         passed in has or <code>null</code>.
      */
     public Project getIndirectDependencyToSameArtifact(final Project project) {
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         Project result =
             getProjectFromProjectList(project, indirectDependencies, false);
         return result;
     }
 
     /***
      * @return The indirect dependencies of type {@link Project}.
      */
     public Iterator getIndirectDependencies() {
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         return indirectDependencies.iterator();
     }
 
     /***
      * Adds an indirect dependency to this project. Does <i>not</i> notify
      * change listeners (is not needed because a user will never directly add
      * such a dependency through the user interface).
      *
      * @param dependency The indirect dependency to add.
      */
     public void addIndirectDependency(final Project dependency) {
         if (indirectDependencies == null) {
             indirectDependencies = new ArrayList();
         }
         indirectDependencies.add(dependency);
         Collections.sort(indirectDependencies, projectComparator);
     }
 
     /***
      * Removes the indirect dependency and notifies change listeners.
      *
      * @param dependency The dependency to remove.
      */
     public void removeIndirectDependency(final Project dependency) {
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         indirectDependencies.remove(dependency);
         fireRemovedIndirectDependency(dependency);
     }
 
     /***
      * @param indirectDependencies The list of indirect dependencies of type
      *                             {@link Project}.
      */
     public void setIndirectDependencies(final List indirectDependencies) {
         Collections.sort(indirectDependencies, projectComparator);
         this.indirectDependencies = indirectDependencies;
     }
 
     /***
      * @param project The dependency to check for.
      * @return <code>true</code> if this project has a direct or indirect
      *         dependency to the project passed in.
      */
     public boolean hasDirectOrIndirectDependency(final Project project) {
         boolean result =
             hasDependency(project) || hasIndirectDependency(project);
         return result;
     }
 
     /***
      * Adds a dependency stated literally in this project's project.xml but
      * which was overruled by some other version of the same artifact.
      *
      * @param deprecatedDependency The dependency to add.
      */
     public void addDeprecatedDependency(final Project deprecatedDependency) {
         deprecatedDependencies.add(deprecatedDependency);
         Collections.sort(deprecatedDependencies, projectComparator);
     }
 
     /***
      * @return The merged and globally sorted list of both the direct and the
      *         indirect dependencies of this project. Elements of the list are
      *         of type {@link Project}.
      */
     public List getAllDependencies() {
         List result = new ArrayList(dependencies);
         if (indirectDependencies == null) {
             indirectDependencies = findIndirectDependencies();
         }
         result.addAll(indirectDependencies);
         Collections.sort(result, projectComparator);
         return result;
     }
 
     /***
      * @return The projects of type {@link Project} which depend on this
      *         project.
      */
     public List getClients() {
         return clients;
     }
 
     /***
      * @return The version conflicts in the dependency graph that roots in this
      *         project.
      */
     public List getConflicts() {
         if (conflicts == null) {
             conflicts = findConflicts();
         }
         return conflicts;
     }
 
     /***
      * Adds a list of properties for the artifact id to this project.
      *
      * @param dependencyArtifactId The artifact id of the dependency that has
      *                             these properties defined in this project's
      *                             POM file.
      * @param propertyXmlElements The list of associated properties of type
      *                            {@link org.jdom.Element}.
      */
     public void addDependencyPropertyList(
             final String dependencyArtifactId,
             final List propertyXmlElements) {
         dependencyProperties.put(dependencyArtifactId, propertyXmlElements);
     }
 
     /***
      * @param dependencyArtifactId The artifact id of the dependency to retrieve
      *                             properties for.
      * @return A list of properties of type {@link org.jdom.Element} or
      *         <code>null</code>.
      */
     public List getDependencyPropertyList(final String dependencyArtifactId) {
         List result = (List) dependencyProperties.get(dependencyArtifactId);
         return result;
     }
 
     /***
      * Adds a change listener to this project which will be notified when this
      * project changed in defined ways.
      *
      * @param listener The listener to add.
      */
     public void addChangeListener(final ProjectChangeListener listener) {
         if (!changeListeners.contains(listener)) {
             changeListeners.add(listener);
         }
     }
 
     /***
      * Removes a change listener from this project.
      *
      * @param listener The listener to remove.
      */
     public void removeChangeListener(final ProjectChangeListener listener) {
         changeListeners.remove(listener);
     }
 
     /*(non-Javadoc)
      * @see java.lang.Object#toString()
      */
     /***
      * {@inheritDoc}
      */
     public String toString() {
         StringBuffer buffer = new StringBuffer(groupId + "");
         buffer.append("/");
         buffer.append(artifactId);
         buffer.append("-");
         buffer.append(version);
         return buffer.toString();
     }
 
     /***
      * @param project The project to check for in the <code>projectList</code>.
      * @param projectList The projectList with objects of type {@link Project}.
      * @param exactMatch Whether to compare by artifact id and version (=exact)
      *                   or only by artifact id.
      * @return <code>true</code> if the project logically occurs in the project
      *         list.
      */
     private boolean projectOccursInProjectList(
             final Project project,
             final List projectList,
             final boolean exactMatch) {
         boolean result =
             getProjectFromProjectList(project, projectList, exactMatch) != null;
         return result;
     }
 
     /***
      * @param project The project to check for in the <code>projectList</code>.
      * @param projectList The projectList with objects of type {@link Project}.
      * @param exactMatch Whether to compare by artifact id and version (=exact)
      *                   or only by artifact id.
      * @return The project from the project list which is logically equivalent
      *         to <code>project</code>.
      */
     private Project getProjectFromProjectList(
             final Project project,
             final List projectList,
             final boolean exactMatch) {
         Project result = null;
         for (Iterator iter = projectList.iterator(); iter.hasNext();) {
             Project dependency = (Project) iter.next();
             if (dependency.getGroupId().equals(project.getGroupId())
                     && dependency.getArtifactId().equals(
                             project.getArtifactId())) {
                 if (exactMatch) {
                     if (dependency.getVersion().equals(project.getVersion())) {
                         result = dependency;
                     }
                 } else {
                     result = dependency;
                 }
                 if (result != null) {
                     break;
                 }
             }
         }
         return result;
     }
 
     /***
      * Flattens the graph of indirect dependencies of this project and returns
      * them without duplicates in a list.
      *
      * @return The list of indirect dependencies of type {@link Project} of this
      *         project. Maybe empty but not <code>null</code>.
      */
     private List findIndirectDependencies() {
         List flattenedDependencies = new ArrayList();
         flattenDependenciesForIndirectDependencies(this, flattenedDependencies);
         sortProjects(flattenedDependencies);
         return flattenedDependencies;
     }
 
     /***
      * @return The list of version conflicts of type
      *         {@link ProjectConflictGroup} of this project.
      */
     private List findConflicts() {
         List flattenedDependencies = new ArrayList();
         flattenDependenciesForConflicts(this, flattenedDependencies);
         sortProjects(flattenedDependencies);
         List results = new ArrayList();
         ProjectConflictGroup conflictGroup = new ProjectConflictGroup();
         String conflictArtifactId = "";
         for (Iterator iter = flattenedDependencies.iterator();
                 iter.hasNext();) {
             Project project = (Project) iter.next();
             if (conflictGroup.getProjects().size() == 0) {
                 conflictGroup.getProjects().add(project);
                 conflictArtifactId = project.getArtifactId();
                 conflictGroup.setArtifactId(conflictArtifactId);
             } else if (project.getArtifactId().equals(conflictArtifactId)) {
                 conflictGroup.getProjects().add(project);
             } else {
                 if (conflictGroup.getProjects().size() > 1) {
                     results.add(conflictGroup);
                 }
                 conflictGroup = new ProjectConflictGroup();
                 conflictGroup.getProjects().add(project);
                 conflictArtifactId = project.getArtifactId();
                 conflictGroup.setArtifactId(conflictArtifactId);
             }
         }
         return results;
     }
 
     /***
      * Flattens all dependencies and all overruled dependencies as the basis
      * to find version conflicts in the dependency graph.
      *
      * @param project The project to be used as root of the (sub) graph to be
      *                flattened and collected in the list.
      * @param flattenedDependencies The list to collect all flattened
      *                              dependencies in.
      */
     private void flattenDependenciesForConflicts(
             final Project project,
             final List flattenedDependencies) {
         Set mergedDependencies = new HashSet(project.dependencies);
         mergedDependencies.addAll(project.deprecatedDependencies);
         for (Iterator iter = mergedDependencies.iterator(); iter.hasNext();) {
             Project dependencyProject = (Project) iter.next();
             if (!flattenedDependencies.contains(dependencyProject)) {
                 flattenedDependencies.add(dependencyProject);
                 flattenDependenciesForConflicts(
                     dependencyProject, flattenedDependencies);
             }
         }
     }
 
     /***
      * Flattens all dependencies as the basis to find all indirect dependencies.
      *
      * @param project The project to be used as root of the (sub) graph to be
      *                flattened and collected in the list. The
      *                <code>project</code> itself will not be added to the list.
      * @param flattenedDependencies The list to collect all flattened
      *                              dependencies in.
      */
     private void flattenDependenciesForIndirectDependencies(
             final Project project,
             final List flattenedDependencies) {
         Set dependencySet = new HashSet(project.dependencies);
         for (Iterator iter = dependencySet.iterator(); iter.hasNext();) {
             Project dependencyProject = (Project) iter.next();
             if (!flattenedDependencies.contains(dependencyProject)) {
                 flattenedDependencies.add(dependencyProject);
                 flattenDependenciesForIndirectDependencies(
                     dependencyProject, flattenedDependencies);
             }
         }
         if (project == this) {
             flattenedDependencies.removeAll(dependencies);
         }
     }
 
     /***
      * @param projects The list of Maven projects to sort.
      */
     private void sortProjects(final List projects) {
         Collections.sort(projects, new ProjectComparator());
     }
 
     /***
      * Notifies listeners that a direct dependency has been added to this
      * project.
      *
      * @param addedDependency The added dependency.
      * @param index The index of the added dependency in the sorted list of all
      *              dependencies of this project.
      */
     private void fireAddedDependency(
             final Project addedDependency,
             final int index) {
         for (Iterator iter = changeListeners.iterator(); iter.hasNext();) {
             ProjectChangeListener listener =
                 (ProjectChangeListener) iter.next();
             listener.addedDependency(addedDependency, index);
         }
     }
 
     /***
      * Notifies listeners that a direct dependency has been removed from this
      * project.
      *
      * @param removedDependency The removed dependency.
      */
     private void fireRemovedDependency(final Project removedDependency) {
         for (Iterator iter = changeListeners.iterator(); iter.hasNext();) {
             ProjectChangeListener listener =
                 (ProjectChangeListener) iter.next();
             listener.removedDependency(removedDependency);
         }
     }
 
     /***
      * Notifies listeners that an indirect dependency has been removed from this
      * project.
      *
      * @param removedDependency The removed dependency.
      */
     private void fireRemovedIndirectDependency(
             final Project removedDependency) {
         for (Iterator iter = changeListeners.iterator(); iter.hasNext();) {
             ProjectChangeListener listener =
                 (ProjectChangeListener) iter.next();
             listener.removedIndirectDependency(removedDependency);
         }
     }
 }