1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package com.intellij.openapi.externalSystem.model.project;
import com.intellij.openapi.externalSystem.model.ProjectSystemId;
import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.containers.ContainerUtilRt;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.File;
import java.io.Serializable;
import java.util.*;
/**
* @author Denis Zhdanov
* @since 8/9/11 6:25 PM
*/
public class ContentRootData extends AbstractExternalEntityData {
private static final long serialVersionUID = 1L;
@NotNull private final Map<ExternalSystemSourceType, Collection<SourceRoot>> myData = ContainerUtilRt.newHashMap();
@NotNull private final String myRootPath;
/**
* Creates new <code>GradleContentRootImpl</code> object.
*
* @param rootPath path to the root directory
*/
public ContentRootData(@NotNull ProjectSystemId owner, @NotNull String rootPath) {
super(owner);
myRootPath = ExternalSystemApiUtil.toCanonicalPath(rootPath);
}
/**
* @param type target dir type
* @return directories of the target type configured for the current content root
*/
@NotNull
public Collection<SourceRoot> getPaths(@NotNull ExternalSystemSourceType type) {
final Collection<SourceRoot> result = myData.get(type);
return result == null ? Collections.<SourceRoot>emptyList() : result;
}
public void storePath(@NotNull ExternalSystemSourceType type, @NotNull String path) throws IllegalArgumentException {
storePath(type, path, null);
}
/**
* Ask to remember that directory at the given path contains sources of the given type.
*
* @param type target sources type
* @param path target source directory path
* @param packagePrefix target source directory package prefix
* @throws IllegalArgumentException if given path points to the directory that is not located
* under the {@link #getRootPath() content root}
*/
public void storePath(@NotNull ExternalSystemSourceType type, @NotNull String path, @Nullable String packagePrefix) throws IllegalArgumentException {
if (FileUtil.isAncestor(new File(getRootPath()), new File(path), false)) {
Collection<SourceRoot> paths = myData.get(type);
if (paths == null) {
myData.put(type, paths = new TreeSet<SourceRoot>(SourceRootComparator.INSTANCE));
}
paths.add(new SourceRoot(
ExternalSystemApiUtil.toCanonicalPath(path),
StringUtil.nullize(packagePrefix, true)
));
return;
}
if (!ExternalSystemSourceType.EXCLUDED.equals(type)) { // There are external systems which mark output directory as 'excluded' path.
// We don't need to bother if it's outside a module content root then.
throw new IllegalArgumentException(String.format(
"Can't register given path of type '%s' because it's out of content root.%nContent root: '%s'%nGiven path: '%s'",
type, getRootPath(), new File(path).getAbsolutePath()
));
}
}
@NotNull
public String getRootPath() {
return myRootPath;
}
@Override
public String toString() {
StringBuilder buffer = new StringBuilder("content root:");
for (Map.Entry<ExternalSystemSourceType, Collection<SourceRoot>> entry : myData.entrySet()) {
buffer.append(entry.getKey().toString().toLowerCase(Locale.ENGLISH)).append("=").append(entry.getValue()).append("|");
}
if (!myData.isEmpty()) {
buffer.setLength(buffer.length() - 1);
}
return buffer.toString();
}
public static class SourceRoot implements Serializable {
@NotNull
private final String myPath;
@Nullable
private final String myPackagePrefix;
public SourceRoot(@NotNull String path, @Nullable String prefix) {
myPath = path;
myPackagePrefix = prefix;
}
@NotNull
public String getPath() {
return myPath;
}
@Nullable
public String getPackagePrefix() {
return myPackagePrefix;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof SourceRoot)) return false;
SourceRoot root = (SourceRoot)o;
if (myPackagePrefix != null ? !myPackagePrefix.equals(root.myPackagePrefix) : root.myPackagePrefix != null) return false;
if (!myPath.equals(root.myPath)) return false;
return true;
}
@Override
public int hashCode() {
int result = myPath.hashCode();
result = 31 * result + (myPackagePrefix != null ? myPackagePrefix.hashCode() : 0);
return result;
}
@Override
public String toString() {
StringBuilder buffer = new StringBuilder("source_root(");
buffer.append(myPath);
if (myPackagePrefix != null) {
buffer.append(", ").append(myPackagePrefix);
}
buffer.append(")");
return buffer.toString();
}
}
private static final class SourceRootComparator implements Comparator<SourceRoot>, Serializable {
private static final SourceRootComparator INSTANCE = new SourceRootComparator();
@Override
public int compare(@NotNull SourceRoot o1, @NotNull SourceRoot o2) {
return StringUtil.naturalCompare(o1.myPath, o2.myPath);
}
}
}
|
