cleanup: remove useless '@author nik' from javadoc comments
[idea/community.git] / jps / model-impl / src / org / jetbrains / jps / model / java / impl / JpsJavaExtensionServiceImpl.java
1 /*
2  * Copyright 2000-2017 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
3  */
4 package org.jetbrains.jps.model.java.impl;
5
6 import com.intellij.openapi.util.io.FileUtil;
7 import org.jetbrains.annotations.NotNull;
8 import org.jetbrains.annotations.Nullable;
9 import org.jetbrains.jps.model.JpsDummyElement;
10 import org.jetbrains.jps.model.JpsGlobal;
11 import org.jetbrains.jps.model.JpsProject;
12 import org.jetbrains.jps.model.java.*;
13 import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration;
14 import org.jetbrains.jps.model.java.impl.compiler.JpsJavaCompilerConfigurationImpl;
15 import org.jetbrains.jps.model.java.impl.runConfiguration.JpsApplicationRunConfigurationPropertiesImpl;
16 import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationProperties;
17 import org.jetbrains.jps.model.java.runConfiguration.JpsApplicationRunConfigurationState;
18 import org.jetbrains.jps.model.library.JpsOrderRootType;
19 import org.jetbrains.jps.model.library.JpsTypedLibrary;
20 import org.jetbrains.jps.model.library.sdk.JpsSdk;
21 import org.jetbrains.jps.model.library.sdk.JpsSdkReference;
22 import org.jetbrains.jps.model.module.JpsDependencyElement;
23 import org.jetbrains.jps.model.module.JpsModule;
24 import org.jetbrains.jps.model.module.JpsModuleReference;
25 import org.jetbrains.jps.model.module.JpsTestModuleProperties;
26 import org.jetbrains.jps.model.module.impl.JpsTestModulePropertiesImpl;
27 import org.jetbrains.jps.util.JpsPathUtil;
28
29 import java.io.File;
30 import java.util.ArrayList;
31 import java.util.Collection;
32 import java.util.Collections;
33 import java.util.List;
34
35 public class JpsJavaExtensionServiceImpl extends JpsJavaExtensionService {
36   @NotNull
37   @Override
38   public JpsJavaProjectExtension getOrCreateProjectExtension(@NotNull JpsProject project) {
39     return project.getContainer().getOrSetChild(JavaProjectExtensionRole.INSTANCE);
40   }
41
42   @Nullable
43   @Override
44   public JpsJavaProjectExtension getProjectExtension(@NotNull JpsProject project) {
45     return project.getContainer().getChild(JavaProjectExtensionRole.INSTANCE);
46   }
47
48   @NotNull
49   @Override
50   public JpsJavaModuleExtension getOrCreateModuleExtension(@NotNull JpsModule module) {
51     return module.getContainer().getOrSetChild(JavaModuleExtensionRole.INSTANCE);
52   }
53
54   @NotNull
55   @Override
56   public JpsJavaDependencyExtension getOrCreateDependencyExtension(@NotNull JpsDependencyElement dependency) {
57     return dependency.getContainer().getOrSetChild(JpsJavaDependencyExtensionRole.INSTANCE);
58   }
59
60   @Override
61   public JpsJavaDependencyExtension getDependencyExtension(@NotNull JpsDependencyElement dependency) {
62     return dependency.getContainer().getChild(JpsJavaDependencyExtensionRole.INSTANCE);
63   }
64
65   @Override
66   @Nullable
67   public JpsJavaModuleExtension getModuleExtension(@NotNull JpsModule module) {
68     return module.getContainer().getChild(JavaModuleExtensionRole.INSTANCE);
69   }
70
71   @Override
72   @NotNull
73   public ExplodedDirectoryModuleExtension getOrCreateExplodedDirectoryExtension(@NotNull JpsModule module) {
74     return module.getContainer().getOrSetChild(ExplodedDirectoryModuleExtensionImpl.ExplodedDirectoryModuleExtensionRole.INSTANCE);
75   }
76
77   @Override
78   @Nullable
79   public ExplodedDirectoryModuleExtension getExplodedDirectoryExtension(@NotNull JpsModule module) {
80     return module.getContainer().getChild(ExplodedDirectoryModuleExtensionImpl.ExplodedDirectoryModuleExtensionRole.INSTANCE);
81   }
82
83   @NotNull
84   @Override
85   public List<JpsDependencyElement> getDependencies(JpsModule module, JpsJavaClasspathKind classpathKind, boolean exportedOnly) {
86     final List<JpsDependencyElement> result = new ArrayList<>();
87     for (JpsDependencyElement dependencyElement : module.getDependenciesList().getDependencies()) {
88       final JpsJavaDependencyExtension extension = getDependencyExtension(dependencyElement);
89       if (extension == null || extension.getScope().isIncludedIn(classpathKind) && (!exportedOnly || extension.isExported())) {
90         result.add(dependencyElement);
91       }
92     }
93     return result;
94   }
95
96   @Override
97   public LanguageLevel getLanguageLevel(JpsModule module) {
98     final JpsJavaModuleExtension moduleExtension = getModuleExtension(module);
99     if (moduleExtension == null) return null;
100     final LanguageLevel languageLevel = moduleExtension.getLanguageLevel();
101     if (languageLevel != null) return languageLevel;
102     final JpsJavaProjectExtension projectExtension = getProjectExtension(module.getProject());
103     return projectExtension != null ? projectExtension.getLanguageLevel() : null;
104   }
105
106   @Override
107   public String getOutputUrl(JpsModule module, boolean forTests) {
108     final JpsJavaModuleExtension extension = getModuleExtension(module);
109     if (extension == null) return null;
110     if (extension.isInheritOutput()) {
111       JpsJavaProjectExtension projectExtension = getProjectExtension(module.getProject());
112       if (projectExtension == null) return null;
113       final String url = projectExtension.getOutputUrl();
114       if (url == null) return null;
115       return url + "/" + (forTests ? "test" : "production") + "/" + module.getName();
116     }
117     return forTests ? extension.getTestOutputUrl() : extension.getOutputUrl();
118   }
119
120   @Nullable
121   @Override
122   public File getOutputDirectory(JpsModule module, boolean forTests) {
123     String url = getOutputUrl(module, forTests);
124     return url != null ? JpsPathUtil.urlToFile(url) : null;
125   }
126
127   @Override
128   public JpsTypedLibrary<JpsSdk<JpsDummyElement>> addJavaSdk(@NotNull JpsGlobal global, @NotNull String name, @NotNull String homePath) {
129     JdkVersionDetector.JdkVersionInfo jdkInfo = JdkVersionDetector.getInstance().detectJdkVersionInfo(homePath);
130     assert jdkInfo != null : homePath;
131     String version = JdkVersionDetector.formatVersionString(jdkInfo.version);
132     JpsTypedLibrary<JpsSdk<JpsDummyElement>> sdk = global.addSdk(name, homePath, version, JpsJavaSdkType.INSTANCE);
133     File homeDir = new File(FileUtil.toSystemDependentName(homePath));
134     List<File> roots = JavaSdkUtil.getJdkClassesRoots(homeDir, false);
135     for (File root : roots) {
136       sdk.addRoot(root, JpsOrderRootType.COMPILED);
137     }
138     return sdk;
139   }
140
141   @NotNull
142   @Override
143   public JpsJavaCompilerConfiguration getCompilerConfiguration(@NotNull JpsProject project) {
144     return project.getContainer().getOrSetChild(JpsJavaCompilerConfigurationImpl.ROLE);
145   }
146
147   @Deprecated
148   @NotNull
149   @Override
150   public JpsJavaCompilerConfiguration getOrCreateCompilerConfiguration(@NotNull JpsProject project) {
151     return getCompilerConfiguration(project);
152   }
153
154   @Nullable
155   @Override
156   public JpsTestModuleProperties getTestModuleProperties(@NotNull JpsModule module) {
157     return module.getContainer().getChild(JpsTestModulePropertiesImpl.ROLE);
158   }
159
160   @Override
161   public void setTestModuleProperties(@NotNull JpsModule module, @NotNull JpsModuleReference productionModuleReference) {
162     module.getContainer().setChild(JpsTestModulePropertiesImpl.ROLE, new JpsTestModulePropertiesImpl(productionModuleReference));
163   }
164
165   @NotNull
166   @Override
167   public JpsSdkReference<JpsDummyElement> createWrappedJavaSdkReference(@NotNull JpsJavaSdkTypeWrapper sdkType,
168                                                                         @NotNull JpsSdkReference<?> wrapperReference) {
169     return new JpsWrappedJavaSdkReferenceImpl(sdkType, wrapperReference);
170   }
171
172   @NotNull
173   @Override
174   public JpsApplicationRunConfigurationProperties createRunConfigurationProperties(JpsApplicationRunConfigurationState state) {
175     return new JpsApplicationRunConfigurationPropertiesImpl(state);
176   }
177
178   @NotNull
179   @Override
180   public JavaSourceRootProperties createSourceRootProperties(@NotNull String packagePrefix, boolean isGenerated) {
181     return new JavaSourceRootProperties(packagePrefix, isGenerated);
182   }
183
184   @NotNull
185   @Override
186   public JavaSourceRootProperties createSourceRootProperties(@NotNull String packagePrefix) {
187     return createSourceRootProperties(packagePrefix, false);
188   }
189
190   @NotNull
191   @Override
192   public JavaResourceRootProperties createResourceRootProperties(@NotNull String relativeOutputPath, boolean forGeneratedResource) {
193     return new JavaResourceRootProperties(relativeOutputPath, forGeneratedResource);
194   }
195
196   @Override
197   @NotNull
198   public JpsProductionModuleOutputPackagingElement createProductionModuleOutput(@NotNull JpsModuleReference moduleReference) {
199     return new JpsProductionModuleOutputPackagingElementImpl(moduleReference);
200   }
201
202   @Override
203   @NotNull
204   public JpsProductionModuleSourcePackagingElement createProductionModuleSource(@NotNull JpsModuleReference moduleReference) {
205     return new JpsProductionModuleSourcePackagingElementImpl(moduleReference);
206   }
207
208   @Override
209   @NotNull
210   public JpsTestModuleOutputPackagingElement createTestModuleOutput(@NotNull JpsModuleReference moduleReference) {
211     return new JpsTestModuleOutputPackagingElementImpl(moduleReference);
212   }
213
214   @Override
215   public JpsJavaDependenciesEnumerator enumerateDependencies(Collection<JpsModule> modules) {
216     return new JpsJavaDependenciesEnumeratorImpl(modules);
217   }
218
219   @Override
220   protected JpsJavaDependenciesEnumerator enumerateDependencies(JpsProject project) {
221     return new JpsJavaDependenciesEnumeratorImpl(project.getModules());
222   }
223
224   @Override
225   protected JpsJavaDependenciesEnumerator enumerateDependencies(JpsModule module) {
226     return new JpsJavaDependenciesEnumeratorImpl(Collections.singletonList(module));
227   }
228
229   @NotNull
230   @Override
231   public JavaModuleIndex getJavaModuleIndex(@NotNull JpsProject project) {
232     return project.getContainer().getOrSetChild(JavaModuleIndexRole.INSTANCE, () -> getCompilerConfiguration(project).getCompilerExcludes());
233   }
234 }