1
2
3
4
5 package org.apache.maven.api.model;
6
7 import java.io.Serializable;
8 import java.util.Collections;
9 import java.util.HashMap;
10 import java.util.Map;
11 import java.util.Set;
12 import org.apache.maven.api.annotations.Experimental;
13 import org.apache.maven.api.annotations.Generated;
14 import org.apache.maven.api.annotations.Immutable;
15 import org.apache.maven.api.annotations.Nonnull;
16 import org.apache.maven.api.annotations.NotThreadSafe;
17 import org.apache.maven.api.annotations.ThreadSafe;
18
19
20
21
22
23
24
25
26
27 @Experimental
28 @Generated @ThreadSafe @Immutable
29 public class ActivationFile
30 implements Serializable, InputLocationTracker
31 {
32
33
34
35
36 final String missing;
37
38
39
40 final String exists;
41
42 final Map<Object, InputLocation> locations;
43
44 final InputLocation importedFrom;
45
46
47
48
49
50 protected ActivationFile(Builder builder) {
51 this.missing = builder.missing != null ? builder.missing : (builder.base != null ? builder.base.missing : null);
52 this.exists = builder.exists != null ? builder.exists : (builder.base != null ? builder.base.exists : null);
53 Map<Object, InputLocation> newlocs = builder.locations != null ? builder.locations : Collections.emptyMap();
54 Map<Object, InputLocation> oldlocs = builder.base != null && builder.base.locations != null ? builder.base.locations : Collections.emptyMap();
55 Map<Object, InputLocation> mutableLocations = new HashMap<>();
56 this.importedFrom = builder.importedFrom;
57 mutableLocations.put("", newlocs.containsKey("") ? newlocs.get("") : oldlocs.get(""));
58 mutableLocations.put("missing", newlocs.containsKey("missing") ? newlocs.get("missing") : oldlocs.get("missing"));
59 mutableLocations.put("exists", newlocs.containsKey("exists") ? newlocs.get("exists") : oldlocs.get("exists"));
60 this.locations = Collections.unmodifiableMap(mutableLocations);
61 }
62
63
64
65
66
67
68
69 public String getMissing() {
70 return this.missing;
71 }
72
73
74
75
76
77
78 public String getExists() {
79 return this.exists;
80 }
81
82
83
84
85 public InputLocation getLocation(Object key) {
86 return locations != null ? locations.get(key) : null;
87 }
88
89
90
91
92 public Set<Object> getLocationKeys() {
93 return locations != null ? locations.keySet() : null;
94 }
95
96
97
98
99 public InputLocation getImportedFrom()
100 {
101 return importedFrom;
102 }
103
104
105
106
107
108
109 @Nonnull
110 public Builder with() {
111 return newBuilder(this);
112 }
113
114
115
116
117
118
119 @Nonnull
120 public ActivationFile withMissing(String missing) {
121 return newBuilder(this, true).missing(missing).build();
122 }
123
124
125
126
127
128
129 @Nonnull
130 public ActivationFile withExists(String exists) {
131 return newBuilder(this, true).exists(exists).build();
132 }
133
134
135
136
137
138
139
140
141 @Nonnull
142 public static ActivationFile newInstance() {
143 return newInstance(true);
144 }
145
146
147
148
149
150
151
152
153 @Nonnull
154 public static ActivationFile newInstance(boolean withDefaults) {
155 return newBuilder(withDefaults).build();
156 }
157
158
159
160
161
162
163
164
165 @Nonnull
166 public static Builder newBuilder() {
167 return newBuilder(true);
168 }
169
170
171
172
173
174
175
176 @Nonnull
177 public static Builder newBuilder(boolean withDefaults) {
178 return new Builder(withDefaults);
179 }
180
181
182
183
184
185
186
187
188 @Nonnull
189 public static Builder newBuilder(ActivationFile from) {
190 return newBuilder(from, false);
191 }
192
193
194
195
196
197
198
199
200 @Nonnull
201 public static Builder newBuilder(ActivationFile from, boolean forceCopy) {
202 return new Builder(from, forceCopy);
203 }
204
205
206
207
208
209
210 @NotThreadSafe
211 public static class Builder
212 {
213 ActivationFile base;
214 String missing;
215 String exists;
216 Map<Object, InputLocation> locations;
217 InputLocation importedFrom;
218
219 protected Builder(boolean withDefaults) {
220 if (withDefaults) {
221 }
222 }
223
224 protected Builder(ActivationFile base, boolean forceCopy) {
225 if (forceCopy) {
226 this.missing = base.missing;
227 this.exists = base.exists;
228 this.locations = base.locations;
229 this.importedFrom = base.importedFrom;
230 } else {
231 this.base = base;
232 }
233 }
234
235 @Nonnull
236 public Builder missing(String missing) {
237 this.missing = missing;
238 return this;
239 }
240
241 @Nonnull
242 public Builder exists(String exists) {
243 this.exists = exists;
244 return this;
245 }
246
247
248 @Nonnull
249 public Builder location(Object key, InputLocation location) {
250 if (location != null) {
251 if (!(this.locations instanceof HashMap)) {
252 this.locations = this.locations != null ? new HashMap<>(this.locations) : new HashMap<>();
253 }
254 this.locations.put(key, location);
255 }
256 return this;
257 }
258
259 @Nonnull
260 public Builder importedFrom(InputLocation importedFrom) {
261 this.importedFrom = importedFrom;
262 return this;
263 }
264
265 @Nonnull
266 public ActivationFile build() {
267
268 if (base != null
269 && (missing == null || missing == base.missing)
270 && (exists == null || exists == base.exists)
271 ) {
272 return base;
273 }
274 return new ActivationFile(this);
275 }
276 }
277
278 }