Tools/Source/GenBuild/org/tianocore/build/toolchain/ToolChainInfo.java

   1 package org.tianocore.build.toolchain;
   2
   3 import java.util.HashMap;
   4 import java.util.LinkedHashSet;
   5 import java.util.Map;
   6 import java.util.Set;
   7
   8 public class ToolChainInfo {
   9
  10     private Set<String> targets = new LinkedHashSet<String>();
  11
  12     private Set<String> tagnames = new LinkedHashSet<String>();
  13
  14     private Set<String> archs = new LinkedHashSet<String>();
  15
  16     private Set<String> commands = new LinkedHashSet<String>();
  17
  18     private Map<String, Set<String>> commandMap = new HashMap<String, Set<String>>();
  19
  20     public void addTargets(String targetList) {
  21         //
  22         // targetList some targets separated by space " "
  23         //
  24         if (targetList == null) {
  25             targets.add("*");
  26             return ;
  27         }
  28         addTargets(targetList.split(" "));
  29     }
  30
  31     public void addTargets(String[] targetArray) {
  32         if (targetArray == null ) {
  33             return ;
  34         }
  35         for (int i = 0; i < targetArray.length; i++) {
  36             targets.add(targetArray[i]);
  37         }
  38     }
  39
  40     public void addTargets(Set<String> targetSet) {
  41         targets.addAll(targetSet);
  42     }
  43
  44     public void addTagnames(String tagnameList) {
  45         //
  46         // tagnameList some tagnames separated by space " "
  47         //
  48         if (tagnameList == null) {
  49             tagnames.add("*");
  50             return ;
  51         }
  52         addTagnames(tagnameList.split(" "));
  53     }
  54
  55     public void addTagnames(String[] tagnameArray) {
  56         if (tagnameArray == null ) {
  57             return ;
  58         }
  59         for (int i = 0; i < tagnameArray.length; i++) {
  60             tagnames.add(tagnameArray[i]);
  61         }
  62     }
  63
  64     public void addTagnames(Set<String> tagnameSet) {
  65         tagnames.addAll(tagnameSet);
  66     }
  67
  68     public void addArchs(String archList) {
  69         //
  70         // archList some archs separated by space " "
  71         //
  72         if (archList == null) {
  73             archs.add("*");
  74             return ;
  75         }
  76         addArchs(archList.split(" "));
  77     }
  78
  79     public void addArchs(String[] archArray) {
  80         if (archArray == null ) {
  81             return ;
  82         }
  83         for (int i = 0; i < archArray.length; i++) {
  84             archs.add(archArray[i]);
  85         }
  86     }
  87
  88     public void addArchs(Set<String> archSet) {
  89         archs.addAll(archSet);
  90     }
  91
  92     public void addCommands(String toolChain, String commandList) {
  93         //
  94         // archList some archs separated by space " "
  95         //
  96         if (commandList == null || commandList.length() == 0) {
  97             return ;
  98         }
  99         addCommands(commandList.split(" "));
 100     }
 101
 102     public void addCommands(String[] commandArray) {
 103         if (commandArray == null ) {
 104             return ;
 105         }
 106         for (int i = 0; i < commandArray.length; i++) {
 107             commands.add(commandArray[i]);
 108         }
 109     }
 110
 111     public void addCommands(String toolChain, String[] commandArray) {
 112         if (commandArray == null) {
 113             return ;
 114         }
 115
 116         Set<String> toolChainCommandSet = commandMap.get(toolChain);
 117         if (toolChainCommandSet == null) {
 118             toolChainCommandSet = new LinkedHashSet<String>();
 119             commandMap.put(toolChain, toolChainCommandSet);
 120         }
 121         for (int i = 0; i < commandArray.length; i++) {
 122             commands.add(commandArray[i]);
 123             toolChainCommandSet.add(commandArray[i]);
 124         }
 125     }
 126
 127     public void addCommands(String toolChain, Set<String> commandSet) {
 128         if (commandSet == null) {
 129             return;
 130         }
 131         Set<String> toolChainCommandSet = commandMap.get(toolChain);
 132         if (toolChainCommandSet == null) {
 133             toolChainCommandSet = new LinkedHashSet<String>();
 134             commandMap.put(toolChain, toolChainCommandSet);
 135         }
 136         commands.addAll(commandSet);
 137         toolChainCommandSet.addAll(commandSet);
 138     }
 139
 140     public ToolChainInfo union(ToolChainInfo info) {
 141         ToolChainInfo result = new ToolChainInfo();
 142         result.addTargets(union(this.targets, info.targets));
 143         result.addTagnames(union(this.tagnames, info.tagnames));
 144         result.addArchs(union(this.archs, info.archs));
 145         //result.addCommands(union(this.getCommands(), info.getCommands()));
 146         return result;
 147     }
 148
 149     public ToolChainInfo intersection(ToolChainInfo info) {
 150 //        System.out.println(this + "\n" + info);
 151         ToolChainInfo result = new ToolChainInfo();
 152         result.addTargets(intersection(this.targets, info.targets));
 153         result.addTagnames(intersection(this.tagnames, info.tagnames));
 154         result.addArchs(intersection(this.archs, info.archs));
 155         // result.addCommands(union(this.commands, info.commands));
 156 //        System.out.println("result: " + result);
 157         return result;
 158     }
 159
 160     private Set<String> union(Set<String> set1, Set<String> set2) {
 161         Set<String> result = new LinkedHashSet<String>();
 162         result.addAll(set1);
 163         result.addAll(set2);
 164         result.remove("*");
 165         return result;
 166     }
 167
 168     private Set<String> intersection(Set<String> set1, Set<String> set2) {
 169         Set<String> result = new LinkedHashSet<String>();
 170         boolean set1HasWildcard = set1.contains("*");
 171         boolean set2HasWildcard = set2.contains("*");
 172
 173         if (set1HasWildcard && set2HasWildcard) {
 174             result.addAll(set1);
 175             result.addAll(set2);
 176         } else if (set1HasWildcard) {
 177             result.addAll(set2);
 178         } else if (set2HasWildcard) {
 179             result.addAll(set1);
 180         } else {
 181             result.addAll(set1);
 182             result.retainAll(set2);
 183         }
 184
 185 //        result.remove("*");
 186         return result;
 187     }
 188
 189     public String[] getTargets() {
 190         return (String[])targets.toArray(new String[targets.size()]);
 191     }
 192
 193     public String[] getTagnames() {
 194         return (String[])tagnames.toArray(new String[tagnames.size()]);
 195     }
 196
 197     public String[] getArchs() {
 198         return (String[])archs.toArray(new String[archs.size()]);
 199     }
 200
 201     public String[] getCommands() {
 202         return (String[])commands.toArray(new String[commands.size()]);
 203     }
 204
 205     public Set<String> getCommands(String toolChain) {
 206         return commandMap.get(toolChain);
 207     }
 208
 209     public String toString() {
 210         return targets + "\n" + tagnames + "\n" + archs + "\n" + commands;
 211     }
 212
 213     public void normalize() {
 214         targets.remove("*");
 215         tagnames.remove("*");
 216         archs.remove("*");
 217         commands.remove("*");
 218     }
 219 }