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

   1 /** @file
   2 This file is to define  ToolChainInfo class.
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13
  14 package org.tianocore.build.toolchain;
  15
  16 import java.util.HashMap;
  17 import java.util.LinkedHashSet;
  18 import java.util.Map;
  19 import java.util.Set;
  20
  21 public class ToolChainInfo {
  22     //
  23     // build target set
  24     //
  25     private Set<String> targets = new LinkedHashSet<String>();
  26     //
  27     // tool chain tag name set
  28     //
  29     private Set<String> tagnames = new LinkedHashSet<String>();
  30     //
  31     // build archs set
  32     //
  33     private Set<String> archs = new LinkedHashSet<String>();
  34     //
  35     // build commands set
  36     //
  37     private Set<String> commands = new LinkedHashSet<String>();
  38     //
  39     // build commands for specific tool chain
  40     //
  41     private Map<String, Set<String>> commandMap = new HashMap<String, Set<String>>();
  42     /**
  43      Add a list of targets in the form of string separated by space
  44
  45      @param targetList target list string
  46      **/
  47     public void addTargets(String targetList) {
  48         //
  49         // targetList some targets separated by space " "
  50         //
  51         if (targetList == null) {
  52             targets.add("*");
  53             return ;
  54         }
  55         addTargets(targetList.split(" "));
  56     }
  57     /**
  58      Add a list of targets in the form of string array
  59
  60      @param targetArray target string array
  61      **/
  62     public void addTargets(String[] targetArray) {
  63         if (targetArray == null ) {
  64             return ;
  65         }
  66         for (int i = 0; i < targetArray.length; i++) {
  67             targets.add(targetArray[i]);
  68         }
  69     }
  70     /**
  71      Add a list of target in the form of set
  72
  73      @param targetSet target string set
  74      **/
  75     public void addTargets(Set<String> targetSet) {
  76         targets.addAll(targetSet);
  77     }
  78     /**
  79        Add a list of tool chain tag name in the form of string separated by space
  80
  81        @param tagnameList
  82      **/
  83     public void addTagnames(String tagnameList) {
  84         //
  85         // tagnameList some tagnames separated by space " "
  86         //
  87         if (tagnameList == null) {
  88             tagnames.add("*");
  89             return ;
  90         }
  91         addTagnames(tagnameList.split(" "));
  92     }
  93
  94     public void addTagnames(String[] tagnameArray) {
  95         if (tagnameArray == null ) {
  96             return ;
  97         }
  98         for (int i = 0; i < tagnameArray.length; i++) {
  99             tagnames.add(tagnameArray[i]);
 100         }
 101     }
 102
 103     public void addTagnames(Set<String> tagnameSet) {
 104         tagnames.addAll(tagnameSet);
 105     }
 106
 107     public void addArchs(String archList) {
 108         //
 109         // archList some archs separated by space " "
 110         //
 111         if (archList == null) {
 112             archs.add("*");
 113             return ;
 114         }
 115         addArchs(archList.split(" "));
 116     }
 117
 118     public void addArchs(String[] archArray) {
 119         if (archArray == null ) {
 120             return ;
 121         }
 122         for (int i = 0; i < archArray.length; i++) {
 123             archs.add(archArray[i]);
 124         }
 125     }
 126
 127     public void addArchs(Set<String> archSet) {
 128         archs.addAll(archSet);
 129     }
 130
 131     public void addCommands(String toolChain, String commandList) {
 132         //
 133         // archList some archs separated by space " "
 134         //
 135         if (commandList == null || commandList.length() == 0) {
 136             return ;
 137         }
 138         addCommands(commandList.split(" "));
 139     }
 140
 141     public void addCommands(String[] commandArray) {
 142         if (commandArray == null ) {
 143             return ;
 144         }
 145         for (int i = 0; i < commandArray.length; i++) {
 146             commands.add(commandArray[i]);
 147         }
 148     }
 149
 150     public void addCommands(String toolChain, String[] commandArray) {
 151         if (commandArray == null) {
 152             return ;
 153         }
 154
 155         Set<String> toolChainCommandSet = commandMap.get(toolChain);
 156         if (toolChainCommandSet == null) {
 157             toolChainCommandSet = new LinkedHashSet<String>();
 158             commandMap.put(toolChain, toolChainCommandSet);
 159         }
 160         for (int i = 0; i < commandArray.length; i++) {
 161             commands.add(commandArray[i]);
 162             toolChainCommandSet.add(commandArray[i]);
 163         }
 164     }
 165
 166     public void addCommands(String toolChain, Set<String> commandSet) {
 167         if (commandSet == null) {
 168             return;
 169         }
 170         Set<String> toolChainCommandSet = commandMap.get(toolChain);
 171         if (toolChainCommandSet == null) {
 172             toolChainCommandSet = new LinkedHashSet<String>();
 173             commandMap.put(toolChain, toolChainCommandSet);
 174         }
 175         commands.addAll(commandSet);
 176         toolChainCommandSet.addAll(commandSet);
 177     }
 178
 179     public ToolChainInfo union(ToolChainInfo info) {
 180         ToolChainInfo result = new ToolChainInfo();
 181         result.addTargets(union(this.targets, info.targets));
 182         result.addTagnames(union(this.tagnames, info.tagnames));
 183         result.addArchs(union(this.archs, info.archs));
 184         return result;
 185     }
 186
 187     public ToolChainInfo intersection(ToolChainInfo info) {
 188         ToolChainInfo result = new ToolChainInfo();
 189         result.addTargets(intersection(this.targets, info.targets));
 190         result.addTagnames(intersection(this.tagnames, info.tagnames));
 191         result.addArchs(intersection(this.archs, info.archs));
 192         return result;
 193     }
 194
 195     private Set<String> union(Set<String> set1, Set<String> set2) {
 196         Set<String> result = new LinkedHashSet<String>();
 197         result.addAll(set1);
 198         result.addAll(set2);
 199         result.remove("*");
 200         return result;
 201     }
 202
 203     private Set<String> intersection(Set<String> set1, Set<String> set2) {
 204         Set<String> result = new LinkedHashSet<String>();
 205         boolean set1HasWildcard = set1.contains("*");
 206         boolean set2HasWildcard = set2.contains("*");
 207
 208         if (set1HasWildcard && set2HasWildcard) {
 209             result.addAll(set1);
 210             result.addAll(set2);
 211         } else if (set1HasWildcard) {
 212             result.addAll(set2);
 213         } else if (set2HasWildcard) {
 214             result.addAll(set1);
 215         } else {
 216             result.addAll(set1);
 217             result.retainAll(set2);
 218         }
 219
 220         return result;
 221     }
 222
 223     public String[] getTargets() {
 224         return (String[])targets.toArray(new String[targets.size()]);
 225     }
 226
 227     public String[] getTagnames() {
 228         return (String[])tagnames.toArray(new String[tagnames.size()]);
 229     }
 230
 231     public String[] getArchs() {
 232         return (String[])archs.toArray(new String[archs.size()]);
 233     }
 234
 235     public String[] getCommands() {
 236         return (String[])commands.toArray(new String[commands.size()]);
 237     }
 238
 239     public Set<String> getCommands(String toolChain) {
 240         return commandMap.get(toolChain);
 241     }
 242
 243     public String toString() {
 244         return targets + "\n" + tagnames + "\n" + archs + "\n" + commands;
 245     }
 246
 247     public void normalize() {
 248         targets.remove("*");
 249         tagnames.remove("*");
 250         archs.remove("*");
 251         commands.remove("*");
 252     }
 253 }