platform/projectModel-api/src/com/intellij/openapi/module/ModuleManager.java

   1 /*
   2  * Copyright 2000-2014 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.openapi.module;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.util.InvalidDataException;
  20 import com.intellij.openapi.util.SimpleModificationTracker;
  21 import com.intellij.util.graph.Graph;
  22 import org.jdom.JDOMException;
  23 import org.jetbrains.annotations.NonNls;
  24 import org.jetbrains.annotations.NotNull;
  25 import org.jetbrains.annotations.Nullable;
  26
  27 import java.io.IOException;
  28 import java.util.Comparator;
  29 import java.util.List;
  30
  31 /**
  32  * Provides services for working with the modules of a project.
  33  */
  34 public abstract class ModuleManager extends SimpleModificationTracker {
  35   /**
  36    * Returns the module manager instance for the current project.
  37    *
  38    * @param project the project for which the module manager is requested.
  39    * @return the module manager instance.
  40    */
  41   public static ModuleManager getInstance(@NotNull Project project) {
  42     return project.getComponent(ModuleManager.class);
  43   }
  44
  45   /**
  46    * Creates a module of the specified type at the specified path and adds it to the project
  47    * to which the module manager is related.
  48    *
  49    * @param filePath the path at which the module is created.
  50    * @param moduleTypeId the ID of the module type to create.
  51    * @return the module instance.
  52    */
  53   @NotNull public abstract Module newModule(@NotNull @NonNls String filePath, final String moduleTypeId);
  54
  55   /**
  56    * Loads a module from an .iml file with the specified path and adds it to the project.
  57    *
  58    * @param filePath the path to load the module from.
  59    * @return the module instance.
  60    * @throws InvalidDataException if the data in the .iml file is semantically incorrect.
  61    * @throws IOException if an I/O error occurred when loading the module file.
  62    * @throws JDOMException if the file contains invalid XML data.
  63    * @throws ModuleWithNameAlreadyExists if a module with such a name already exists in the project.
  64    */
  65   @NotNull public abstract Module loadModule(@NotNull String filePath) throws InvalidDataException, IOException, JDOMException, ModuleWithNameAlreadyExists;
  66
  67   /**
  68    * Disposes of the specified module and removes it from the project.
  69    *
  70    * @param module the module to remove.
  71    */
  72   public abstract void disposeModule(@NotNull Module module);
  73
  74   /**
  75    * Returns the list of all modules in the project.
  76    *
  77    * @return the array of modules.
  78    */
  79   @NotNull public abstract Module[] getModules();
  80
  81   /**
  82    * Returns the project module with the specified name.
  83    *
  84    * @param name the name of the module to find.
  85    * @return the module instance, or null if no module with such name exists.
  86    */
  87   @Nullable public abstract Module findModuleByName(@NonNls @NotNull String name);
  88
  89   /**
  90    * Returns the list of modules sorted by dependency (the modules which do not depend
  91    * on anything are in the beginning of the list, a module which depends on another module
  92    * follows it in the list).
  93    *
  94    * @return the sorted array of modules.
  95    */
  96   @NotNull public abstract Module[] getSortedModules();
  97
  98   /**
  99    * Returns the module comparator which can be used for sorting modules by dependency
 100    * (the modules which do not depend on anything are in the beginning of the list,
 101    * a module which depends on another module follows it in the list).
 102    *
 103    * @return the module comparator instance.
 104    */
 105   @NotNull public abstract Comparator<Module> moduleDependencyComparator();
 106
 107   /**
 108    * Returns the list of modules which directly depend on the specified module.
 109    *
 110    * @param module the module for which the list of dependent modules is requested.
 111    * @return list of <i>modules that depend on</i> given module.
 112    *
 113    * @see ModuleUtilCore#getAllDependentModules(Module)
 114    */
 115   @NotNull public abstract List<Module> getModuleDependentModules(@NotNull Module module);
 116
 117   /**
 118    * Checks if one of the specified modules directly depends on the other module.
 119    *
 120    * @param module   the module to check the dependency for.
 121    * @param onModule the module on which <code>module</code> may depend.
 122    * @return true if <code>module</code> directly depends on <code>onModule</code>, false otherwise.
 123    */
 124   public abstract boolean isModuleDependent(@NotNull Module module, @NotNull Module onModule);
 125
 126   /**
 127    * Returns the graph of dependencies between modules in the project.
 128    *
 129    * @return the module dependency graph.
 130    */
 131   @NotNull public abstract Graph<Module> moduleGraph();
 132
 133   /**
 134    * Returns the graph of dependencies between modules in the project.
 135    *
 136    * @param includeTests whether test-only dependencies should be included
 137    * @return the module dependency graph.
 138    * @since 11.0
 139    */
 140   @NotNull public abstract Graph<Module> moduleGraph(boolean includeTests);
 141
 142   /**
 143    * Returns the model for the list of modules in the project, which can be used to add,
 144    * remove or modify modules.
 145    *
 146    * @return the modifiable model instance.
 147    */
 148   @NotNull public abstract ModifiableModuleModel getModifiableModel();
 149
 150
 151   /**
 152    * Returns the path to the group to which the specified module belongs, as an
 153    * array of group names starting from the project root.
 154    *
 155    * @param module the module for which the path is requested.
 156    * @return the path to the group for the module, or null if the module does not belong to any group.
 157    */
 158   @Nullable public abstract String[] getModuleGroupPath(@NotNull Module module);
 159 }