cleanup (inspection "Java | Class structure | Utility class is not 'final'")
[idea/community.git] / jps / jps-builders / src / org / jetbrains / jps / incremental / Utils.java
1 // Copyright 2000-2020 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.
2 package org.jetbrains.jps.incremental;
3
4 import com.intellij.openapi.util.Key;
5 import com.intellij.openapi.util.io.FileUtil;
6 import com.intellij.openapi.util.text.StringUtil;
7 import com.intellij.util.PathUtilRt;
8 import org.jetbrains.annotations.Nullable;
9 import org.jetbrains.jps.builders.BuildTarget;
10 import org.jetbrains.jps.model.serialization.JpsProjectLoader;
11 import org.jetbrains.jps.model.serialization.PathMacroUtil;
12
13 import java.io.File;
14 import java.nio.file.Files;
15 import java.nio.file.Path;
16 import java.nio.file.Paths;
17 import java.util.Collection;
18 import java.util.Map;
19
20 /**
21  * @author Eugene Zhuravlev
22  */
23 public final class Utils {
24   public static final Key<Map<BuildTarget<?>, Collection<String>>> REMOVED_SOURCES_KEY = Key.create("_removed_sources_");
25   public static final Key<Boolean> PROCEED_ON_ERROR_KEY = Key.create("_proceed_on_error_");
26   public static final Key<Boolean> ERRORS_DETECTED_KEY = Key.create("_errors_detected_");
27   private static volatile File ourSystemRoot = new File(System.getProperty("user.home"), ".idea-build");
28   public static final boolean IS_TEST_MODE = Boolean.parseBoolean(System.getProperty("test.mode", "false"));
29   public static final boolean IS_PROFILING_MODE = Boolean.parseBoolean(System.getProperty("profiling.mode", "false"));
30
31   private Utils() {
32   }
33
34   public static File getSystemRoot() {
35     return ourSystemRoot;
36   }
37
38   public static void setSystemRoot(File systemRoot) {
39     ourSystemRoot = systemRoot;
40   }
41
42   @Nullable
43   public static File getDataStorageRoot(String projectPath) {
44     return getDataStorageRoot(ourSystemRoot, projectPath);
45   }
46
47   public static File getDataStorageRoot(final File systemRoot, String projectPath) {
48     projectPath = FileUtil.toCanonicalPath(projectPath);
49     if (projectPath == null) {
50       return null;
51     }
52
53     String name;
54     final int locationHash;
55
56     final Path rootFile = Paths.get(projectPath);
57     if (!Files.isDirectory(rootFile) && projectPath.endsWith(".ipr")) {
58       name = StringUtil.trimEnd(rootFile.getFileName().toString(), ".ipr");
59       locationHash = projectPath.hashCode();
60     }
61     else {
62       Path directoryBased = null;
63       if (rootFile.endsWith(PathMacroUtil.DIRECTORY_STORE_NAME)) {
64         directoryBased = rootFile;
65       }
66       else {
67         Path child = rootFile.resolve(PathMacroUtil.DIRECTORY_STORE_NAME);
68         if (Files.exists(child)) {
69           directoryBased = child;
70         }
71       }
72       if (directoryBased == null) {
73         return null;
74       }
75       name = PathUtilRt.suggestFileName(JpsProjectLoader.getDirectoryBaseProjectName(directoryBased));
76       locationHash = directoryBased.toString().hashCode();
77     }
78
79     return new File(systemRoot, StringUtil.toLowerCase(name) + "_" + Integer.toHexString(locationHash));
80   }
81
82   public static boolean errorsDetected(CompileContext context) {
83     return ERRORS_DETECTED_KEY.get(context, Boolean.FALSE);
84   }
85
86   public static String formatDuration(long duration) {
87     return StringUtil.formatDuration(duration);
88   }
89
90   public static int suggestForkedCompilerHeapSize() {
91     //final JpsProject project = context.getProjectDescriptor().getProject();
92     //final JpsJavaCompilerConfiguration config = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(project);
93     //final JpsJavaCompilerOptions options = config.getCurrentCompilerOptions();
94     //return options.MAXIMUM_HEAP_SIZE;
95     final int maxMbytes = (int)(Runtime.getRuntime().maxMemory() / 1048576L);
96     if (maxMbytes < 0) {
97       return -1; // in case of int overflow, return -1 to let VM choose the heap size
98     }
99     return Math.max(maxMbytes / 3, 256); // per-forked process: minimum 256 Mb, maximum 33% from JPS max heap size
100   }
101 }