Restructuring for better separation of Tool packages.
[mirror_edk2.git] / Tools / Java / Source / GenBuild / org / tianocore / build / toolchain / ToolChainInfo.java
1 /** @file
2 ToolChainInfo class
3
4 This file is to define ToolChainInfo class.
5
6 Copyright (c) 2006, Intel Corporation
7 All rights reserved. This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14 **/
15
16 package org.tianocore.build.toolchain;
17
18 import java.util.LinkedHashSet;
19 import java.util.Set;
20
21 /**
22 ToolChainInfo collects valid build targets, tool chain tag, ARCHs and commands
23 information for real build use.
24 **/
25 public class ToolChainInfo {
26 //
27 // build target set
28 //
29 private Set<String> targets = new LinkedHashSet<String>();
30 //
31 // tool chain tag name set
32 //
33 private Set<String> tagnames = new LinkedHashSet<String>();
34 //
35 // build archs set
36 //
37 private Set<String> archs = new LinkedHashSet<String>();
38 //
39 // build commands set
40 //
41 private Set<String> commands = new LinkedHashSet<String>();
42
43 /**
44 Add a list of targets in the form of string separated by space
45
46 @param targetList target list string
47 **/
48 public void addTargets(String targetList) {
49 //
50 // targetList some targets separated by space " "
51 //
52 if (targetList == null || targetList.length() == 0) {
53 targets.add("*");
54 } else {
55 addTargets(targetList.split(" "));
56 }
57 }
58
59 /**
60 Add a list of targets in the form of string array
61
62 @param targetArray target string array
63 **/
64 public void addTargets(String[] targetArray) {
65 if (targetArray != null ) {
66 for (int i = 0; i < targetArray.length; i++) {
67 targets.add(targetArray[i]);
68 }
69 }
70 }
71
72 /**
73 Add a list of target in the form of set
74
75 @param targetSet target string set
76 **/
77 public void addTargets(Set<String> targetSet) {
78 if (targetSet != null) {
79 targets.addAll(targetSet);
80 }
81 }
82
83 /**
84 Add a list of tool chain tag name in the form of string separated by space
85
86 @param tagnameList Tool chain tag name list string
87 **/
88 public void addTagnames(String tagnameList) {
89 //
90 // tagnameList some tagnames separated by space " "
91 //
92 if (tagnameList == null || tagnameList.length() == 0) {
93 tagnames.add("*");
94 } else {
95 addTagnames(tagnameList.split(" "));
96 }
97 }
98
99 /**
100 Add a list of tool chain tag name in the form of string array
101
102 @param tagnameArray Tool chain tag names array
103 **/
104 public void addTagnames(String[] tagnameArray) {
105 if (tagnameArray != null ) {
106 for (int i = 0; i < tagnameArray.length; i++) {
107 tagnames.add(tagnameArray[i]);
108 }
109 }
110 }
111
112 /**
113 Add a list of tool chain tag name in the form of Set
114
115 @param tagnameSet Tool chain tag names set
116 **/
117 public void addTagnames(Set<String> tagnameSet) {
118 if (tagnameSet != null) {
119 tagnames.addAll(tagnameSet);
120 }
121 }
122
123 /**
124 Add a list of ARCH in the form of string
125
126 @param archList ARCH string
127 **/
128 public void addArchs(String archList) {
129 //
130 // archList some archs separated by space " "
131 //
132 if (archList == null || archList.length() == 0) {
133 archs.add("*");
134 } else {
135 addArchs(archList.split(" "));
136 }
137 }
138
139 /**
140 Add a list of ARCH in the form of string array
141
142 @param archArray ARCH array
143 **/
144 public void addArchs(String[] archArray) {
145 if (archArray != null ) {
146 for (int i = 0; i < archArray.length; i++) {
147 archs.add(archArray[i]);
148 }
149 }
150 }
151
152 /**
153 Add a list of ARCH in the form of set
154
155 @param archSet ARCH set
156 **/
157 public void addArchs(Set<String> archSet) {
158 if (archSet != null) {
159 archs.addAll(archSet);
160 }
161 }
162
163 /**
164 Add a list of command in the form of string
165
166 @param commandList Command list string
167 **/
168 public void addCommands(String commandList) {
169 //
170 // archList some archs separated by space " "
171 //
172 if (commandList == null || commandList.length() == 0) {
173 commands.add("*");
174 } else {
175 addCommands(commandList.split(" "));
176 }
177 }
178
179 /**
180 Add a list of ARCH in the form of array
181
182 @param commandArray Commands array
183 **/
184 public void addCommands(String[] commandArray) {
185 if (commandArray != null ) {
186 for (int i = 0; i < commandArray.length; i++) {
187 commands.add(commandArray[i]);
188 }
189 }
190 }
191
192 /**
193 Add a list of ARCH in the form of set
194
195 @param commandSet Commands set
196 **/
197 public void addCommands(Set<String> commandSet) {
198 if (commandSet != null) {
199 commands.addAll(commandSet);
200 }
201 }
202
203 /**
204 Make a union operation on this ToolChainInfo and the given one.
205
206 @param info Another ToolChainInfo object to merge with
207
208 @return ToolChainInfo Merged ToolChainInfo object
209 **/
210 public ToolChainInfo union(ToolChainInfo info) {
211 ToolChainInfo result = new ToolChainInfo();
212 result.addTargets(union(this.targets, info.targets));
213 result.addTagnames(union(this.tagnames, info.tagnames));
214 result.addArchs(union(this.archs, info.archs));
215 return result;
216 }
217
218 /**
219 Make a intersection operation on this ToolChainInfo and the given one
220
221 @param info Another ToolChainInfo object to intersect with
222
223 @return ToolChainInfo Intersected ToolChainInfo object
224 **/
225 public ToolChainInfo intersection(ToolChainInfo info) {
226 ToolChainInfo result = new ToolChainInfo();
227 result.addTargets(intersection(this.targets, info.targets));
228 result.addTagnames(intersection(this.tagnames, info.tagnames));
229 result.addArchs(intersection(this.archs, info.archs));
230 return result;
231 }
232
233 /**
234 Make a union operation on two Sets
235
236 @param set1 One Set
237 @param set2 Another Set
238
239 @return Set<String> Merged Set object
240 **/
241 private Set<String> union(Set<String> set1, Set<String> set2) {
242 Set<String> result = new LinkedHashSet<String>();
243 result.addAll(set1);
244 result.addAll(set2);
245 result.remove("*");
246 return result;
247 }
248
249 /**
250 Make a intersection operation on two Sets with the consideration of wildcard.
251
252 @param set1 One Set
253 @param set2 Another Set
254
255 @return Set<String> The intersected Set object
256 **/
257 private Set<String> intersection(Set<String> set1, Set<String> set2) {
258 Set<String> result = new LinkedHashSet<String>();
259 boolean set1HasWildcard = set1.contains("*");
260 boolean set2HasWildcard = set2.contains("*");
261
262 if (set1HasWildcard && set2HasWildcard) {
263 //
264 // Both Sets have wildcard, the result will have all elements in them
265 //
266 result.addAll(set1);
267 result.addAll(set2);
268 } else if (set1HasWildcard) {
269 //
270 // Only set1 has wildcard, then result will have only set2 elements.
271 //
272 result.addAll(set2);
273 } else if (set2HasWildcard) {
274 //
275 // Only set2 has wildcard, then result will have only set1 elements.
276 //
277 result.addAll(set1);
278 } else {
279 //
280 // No wildcard in both Sets, the result will have the elements in both Sets.
281 //
282 result.addAll(set1);
283 result.retainAll(set2);
284 }
285
286 return result;
287 }
288
289 /**
290 Get target array.
291
292 @return String[]
293 **/
294 public String[] getTargets() {
295 return (String[])targets.toArray(new String[targets.size()]);
296 }
297
298 /**
299 Get tool chain tag name array.
300
301 @return String[]
302 **/
303 public String[] getTagnames() {
304 return (String[])tagnames.toArray(new String[tagnames.size()]);
305 }
306
307 /**
308 Get ARCH array.
309
310 @return String[]
311 **/
312 public String[] getArchs() {
313 return (String[])archs.toArray(new String[archs.size()]);
314 }
315
316 /**
317 Get command name array.
318
319 @return String[]
320 **/
321 public String[] getCommands() {
322 return (String[])commands.toArray(new String[commands.size()]);
323 }
324
325 /**
326 Override the Object's toString().
327
328 @return String
329 **/
330 public String toString() {
331 return " TARGET :" + targets + "\n" +
332 " TAGNAME:" + tagnames + "\n" +
333 " ARCH :" + archs + "\n" +
334 " COMMAND:" + commands;
335 }
336
337 /**
338 Remove the wildcard element in the tool chain information because they
339 are useless when retrieved.
340 **/
341 public void normalize() {
342 targets.remove("*");
343 tagnames.remove("*");
344 archs.remove("*");
345 commands.remove("*");
346 }
347 }