cleanup (inspection "Java | Class structure | Utility class is not 'final'")
[idea/community.git] / jps / model-serialization / src / org / jetbrains / jps / model / serialization / java / compiler / AnnotationProcessorProfileSerializer.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.model.serialization.java.compiler;
3
4 import com.intellij.openapi.util.io.FileUtil;
5 import com.intellij.openapi.util.text.StringUtil;
6 import org.jdom.Element;
7 import org.jetbrains.annotations.NotNull;
8 import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile;
9
10 import java.io.File;
11 import java.util.*;
12
13 public final class AnnotationProcessorProfileSerializer {
14   private static final Comparator<String> ALPHA_COMPARATOR = (o1, o2) -> o1.compareToIgnoreCase(o2);
15   private static final String ENTRY = "entry";
16   private static final String NAME = "name";
17   private static final String VALUE = "value";
18   private static final String ENABLED = "enabled";
19   private static final String OPTION = "option";
20   private static final String MODULE = "module";
21   private static final String USE_CLASSPATH = "useClasspath";
22   private static final String USE_PROC_MODULE_PATH = "useProcessorModulePath";
23
24   public static void readExternal(ProcessorConfigProfile profile, Element element) {
25     profile.setName(element.getAttributeValue(NAME, ""));
26     profile.setEnabled(Boolean.valueOf(element.getAttributeValue(ENABLED, "false")));
27
28     final Element srcOutput = element.getChild("sourceOutputDir");
29     final String out = srcOutput != null ? srcOutput.getAttributeValue(NAME) : null;
30     profile.setGeneratedSourcesDirectoryName(out != null? FileUtil.toSystemDependentName(out) : null, false);
31
32     final Element srcTestOutput = element.getChild("sourceTestOutputDir");
33     final String testOut = srcTestOutput != null ? srcTestOutput.getAttributeValue(NAME) : null;
34     profile.setGeneratedSourcesDirectoryName(testOut != null? FileUtil.toSystemDependentName(testOut) : null, true);
35
36     final Element isRelativeToContentRoot = element.getChild("outputRelativeToContentRoot");
37     if (isRelativeToContentRoot != null) {
38       profile.setOutputRelativeToContentRoot(Boolean.parseBoolean(isRelativeToContentRoot.getAttributeValue(VALUE)));
39     }
40
41     profile.clearProcessorOptions();
42     for (Object optionElement : element.getChildren(OPTION)) {
43       final Element elem = (Element)optionElement;
44       final String key = elem.getAttributeValue(NAME);
45       final String value = elem.getAttributeValue(VALUE);
46       if (!StringUtil.isEmptyOrSpaces(key) && value != null) {
47         profile.setOption(key, value);
48       }
49     }
50
51     profile.clearProcessors();
52     for (Object procElement : element.getChildren("processor")) {
53       final String name = ((Element)procElement).getAttributeValue(NAME);
54       if (!StringUtil.isEmptyOrSpaces(name)) {
55         profile.addProcessor(name);
56       }
57     }
58
59     final Element pathElement = element.getChild("processorPath");
60     if (pathElement != null) {
61       profile.setObtainProcessorsFromClasspath(Boolean.parseBoolean(pathElement.getAttributeValue(USE_CLASSPATH, "true")));
62       profile.setUseProcessorModulePath(Boolean.parseBoolean(pathElement.getAttributeValue(USE_PROC_MODULE_PATH, "false")));
63       final StringBuilder pathBuilder = new StringBuilder();
64       for (Object entry : pathElement.getChildren(ENTRY)) {
65         final String path = ((Element)entry).getAttributeValue(NAME);
66         if (!StringUtil.isEmptyOrSpaces(path)) {
67           if (pathBuilder.length() > 0) {
68             pathBuilder.append(File.pathSeparator);
69           }
70           pathBuilder.append(FileUtil.toSystemDependentName(path));
71         }
72       }
73       profile.setProcessorPath(pathBuilder.toString());
74     }
75
76     profile.clearModuleNames();
77     for (Object moduleElement : element.getChildren(MODULE)) {
78       final String name = ((Element)moduleElement).getAttributeValue(NAME);
79       if (!StringUtil.isEmptyOrSpaces(name)) {
80         profile.addModuleName(name);
81       }
82     }
83   }
84
85   public static void writeExternal(@NotNull ProcessorConfigProfile profile, @NotNull Element element) {
86     element.setAttribute(NAME, profile.getName());
87     if (profile.isEnabled()) {
88       element.setAttribute(ENABLED, Boolean.toString(profile.isEnabled()));
89     }
90
91     final String srcDirName = profile.getGeneratedSourcesDirectoryName(false);
92     if (!StringUtil.equals(ProcessorConfigProfile.DEFAULT_PRODUCTION_DIR_NAME, srcDirName)) {
93       addChild(element, "sourceOutputDir").setAttribute(NAME, FileUtil.toSystemIndependentName(srcDirName));
94     }
95     final String testSrcDirName = profile.getGeneratedSourcesDirectoryName(true);
96     if (!StringUtil.equals(ProcessorConfigProfile.DEFAULT_TESTS_DIR_NAME, testSrcDirName)) {
97       addChild(element, "sourceTestOutputDir").setAttribute(NAME, FileUtil.toSystemIndependentName(testSrcDirName));
98     }
99
100     if (profile.isOutputRelativeToContentRoot()) {
101       addChild(element, "outputRelativeToContentRoot").setAttribute(VALUE, "true");
102     }
103
104     final Map<String, String> options = profile.getProcessorOptions();
105     if (!options.isEmpty()) {
106       final List<String> keys = new ArrayList<>(options.keySet());
107       keys.sort(ALPHA_COMPARATOR);
108       for (String key : keys) {
109         addChild(element, OPTION).setAttribute(NAME, key).setAttribute(VALUE, options.get(key));
110       }
111     }
112
113     final Set<String> processors = profile.getProcessors();
114     if (!processors.isEmpty()) {
115       final List<String> processorList = new ArrayList<>(processors);
116       for (String proc : processorList) {
117         addChild(element, "processor").setAttribute(NAME, proc);
118       }
119     }
120
121
122     Element pathElement = null;
123     if (!profile.isObtainProcessorsFromClasspath()) {
124       pathElement = addChild(element, "processorPath");
125       pathElement.setAttribute(USE_CLASSPATH, Boolean.toString(profile.isObtainProcessorsFromClasspath()));
126       if (profile.isUseProcessorModulePath()) {
127         pathElement.setAttribute(USE_PROC_MODULE_PATH, Boolean.toString(profile.isUseProcessorModulePath()));
128       }
129     }
130
131     final String path = profile.getProcessorPath();
132     if (!StringUtil.isEmpty(path)) {
133       if (pathElement == null) {
134         pathElement = addChild(element, "processorPath");
135         if (profile.isUseProcessorModulePath()) {
136           pathElement.setAttribute(USE_PROC_MODULE_PATH, Boolean.toString(profile.isUseProcessorModulePath()));
137         }
138       }
139       final StringTokenizer tokenizer = new StringTokenizer(path, File.pathSeparator, false);
140       while (tokenizer.hasMoreTokens()) {
141         final String token = tokenizer.nextToken();
142         addChild(pathElement, ENTRY).setAttribute(NAME, FileUtil.toSystemIndependentName(token));
143       }
144     }
145
146     final Set<String> moduleNames = profile.getModuleNames();
147     if (!moduleNames.isEmpty()) {
148       final List<String> names = new ArrayList<>(moduleNames);
149       for (String name : names) {
150         addChild(element, MODULE).setAttribute(NAME, name);
151       }
152     }
153   }
154
155   private static Element addChild(Element parent, final String childName) {
156     final Element child = new Element(childName);
157     parent.addContent(child);
158     return child;
159   }
160 }