Tools/Source/PcdTools/org/tianocore/pcd/entity/MemoryDatabaseManager.java

   1 /** @file
   2   MemoryDatabaseManager class.
   3
   4   Database hold all PCD information comes from SPD, MSA, FPD file in memory.
   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.pcd.entity;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import org.tianocore.pcd.entity.UsageIdentification;
  24 import org.tianocore.pcd.exception.EntityException;
  25
  26 /**
  27   Database hold all PCD information comes from SPD, MSA, FPD file in memory.
  28 **/
  29 public class MemoryDatabaseManager {
  30     ///
  31     ///  Memory database. The string "cName + SpaceNameGuid" is primary key.
  32     ///  memory database is in global scope, and it will be used for others PCD tools.
  33     ///
  34     private static Map<String, Token>  memoryDatabase       = null;
  35
  36     ///
  37     /// Before build a module, the used libary will be build firstly, the PCD of these
  38     /// library is inheritted by the module, so stored module's PCD information as PCD
  39     /// context of building libary.
  40     ///
  41     public static List<UsageInstance> UsageInstanceContext = null;
  42
  43     ///
  44     /// Current module name, if now is buiding library, this value indicate this library
  45     /// is for building what module.
  46     ///
  47     public static String CurrentModuleName                 = null;
  48
  49     ///
  50     /// String for PCD PEIM and DXE autogen file
  51     ///
  52     public static String PcdPeimHString                    = "";
  53     public static String PcdPeimCString                    = "";
  54     public static String PcdDxeHString                     = "";
  55     public static String PcdDxeCString                     = "";
  56
  57     /**
  58       Constructure function
  59     **/
  60     public MemoryDatabaseManager() {
  61         //
  62         // Allocate memory for new database in global scope.
  63         //
  64         if (memoryDatabase == null) {
  65             memoryDatabase = new HashMap<String, Token>();
  66         }
  67     }
  68
  69     /**
  70       Judege whether token exists in memory database
  71
  72       @param primaryKey    the primaryKey for searching token
  73
  74       @retval  TRUE  - token already exist in database.
  75       @retval  FALSE - token does not exist in database.
  76     **/
  77     public boolean isTokenInDatabase(String primaryKey) {
  78         return (memoryDatabase.get(primaryKey) != null);
  79     }
  80
  81     /**
  82       Add a pcd token into memory database.
  83
  84       @param primaryKey   the primary key for searching token
  85       @param token        token instance
  86     **/
  87     public void addTokenToDatabase(String primaryKey, Token token) {
  88         memoryDatabase.put(primaryKey, token);
  89     }
  90
  91     /**
  92       Get a token instance from memory database with primary key.
  93
  94       @param primaryKey   the primary key for searching token
  95
  96       @return token instance.
  97     **/
  98     public Token getTokenByKey(String primaryKey) {
  99         return memoryDatabase.get(primaryKey);
 100     }
 101
 102     /**
 103       Get the number of PCD token record in memory database.
 104
 105       @return the number of PCD token record in memory database.
 106     **/
 107     public int getDBSize() {
 108         return memoryDatabase.size();
 109     }
 110
 111     /**
 112       Get the token record array contained all PCD token in memory database.
 113
 114       @return the token record array contained all PCD token in memory database.
 115     **/
 116     public Token[] getRecordArray() {
 117         Token[]     tokenArray  = null;
 118         Object[]    dataArray   = null;
 119         Map.Entry   entry       = null;
 120         int         index       = 0;
 121         int         size        = 0;
 122
 123         if (memoryDatabase == null) {
 124             return null;
 125         }
 126         dataArray  = memoryDatabase.entrySet().toArray();
 127         size       = memoryDatabase.size();
 128         tokenArray = new Token[memoryDatabase.size()];
 129         for (index = 0; index < size; index++) {
 130             entry =(Map.Entry) dataArray [index];
 131             tokenArray[index] =(Token) entry.getValue();
 132         }
 133         return tokenArray;
 134     }
 135
 136     /**
 137        Get record array only contains DYNAMIC or DYNAMIC_EX type PCD.
 138
 139        @return ArrayList the array list contains all dynamic type PCD.
 140     **/
 141     private ArrayList getDynamicRecordArray() {
 142         Token[]     tokenArray  =   getRecordArray();
 143         int         index       =   0;
 144         ArrayList<Token>   al   =   new ArrayList<Token>();
 145
 146         for (index = 0; index < tokenArray.length; index++) {
 147             if (tokenArray[index].isDynamicPCD) {
 148                 al.add(tokenArray[index]);
 149             }
 150         }
 151
 152         return al;
 153     }
 154
 155
 156     /**
 157       Get the token record array contained all PCD token referenced by PEI phase.
 158       The output array is sorted based on descending order of the size of alignment for each feilds.
 159
 160       @return the token record array contained all PCD token referenced in PEI phase.
 161       @throws EntityException
 162     **/
 163     public void getTwoPhaseDynamicRecordArray(ArrayList<Token> pei, ArrayList<Token> dxe)
 164         throws EntityException {
 165         int                     usageInstanceIndex  =   0;
 166         int                     index               =   0;
 167         ArrayList               tokenArrayList      =   getDynamicRecordArray();
 168         Object[]                usageInstanceArray  =   null;
 169         UsageInstance           usageInstance       =   null;
 170         int                     size                =   0;
 171         int                     consumerSize        =   0;
 172
 173         size = tokenArrayList.size();
 174         for (index = 0; index < size; index++) {
 175             boolean found   =   false;
 176             Token       token = (Token) tokenArrayList.get(index);
 177             if (token.consumers != null) {
 178                 usageInstanceArray = token.consumers.entrySet().toArray();
 179                 consumerSize       = token.consumers.size();
 180                 for (usageInstanceIndex = 0; usageInstanceIndex < consumerSize; usageInstanceIndex++) {
 181                     usageInstance =(UsageInstance) (((Map.Entry)usageInstanceArray[usageInstanceIndex]).getValue());
 182                     if (usageInstance.isPeiPhaseComponent()) {
 183                         pei.add(token);
 184                         found = true;
 185                         break;
 186                     }
 187                 }
 188             }
 189
 190             //
 191             // If no PEI components reference the PCD entry,
 192             // we check if it is referenced in DXE driver.
 193             //
 194             if (!found) {
 195                 if (token.consumers != null) {
 196                     usageInstanceArray = token.consumers.entrySet().toArray();
 197                     consumerSize       = token.consumers.size();
 198                     for (usageInstanceIndex = 0; usageInstanceIndex < consumerSize; usageInstanceIndex++) {
 199                         usageInstance =(UsageInstance) (((Map.Entry)usageInstanceArray[usageInstanceIndex]).getValue());
 200                         if (usageInstance.isDxePhaseComponent()) {
 201                             dxe.add(token);
 202                             found = true;
 203                             break;
 204                         }
 205                     }
 206                 }
 207
 208                 if (!found) {
 209                     if (token.isDynamicPCD && token.consumers.size() == 0) {
 210                         dxe.add(token);
 211                     } else {
 212                         //
 213                         // We only support Dynamice(EX) type for PEI and DXE phase.
 214                         // If it is not referenced in either PEI or DXE, throw exception now.
 215                         //
 216                         throw new EntityException("[PCD tool Internal Error] Dynamic(EX) PCD Entries are referenced in module that is not in PEI phase nor in DXE phase.");
 217                     }
 218                 }
 219             }
 220         }
 221     }
 222
 223     /**
 224       Get all PCD record for a module according to module's name, module's GUID,
 225       package name, package GUID, arch, version information.
 226
 227       @param usageId   the id of UsageInstance.
 228
 229       @return  all usage instance for this module in memory database.
 230     **/
 231     public List<UsageInstance> getUsageInstanceArrayByModuleName(UsageIdentification usageId) {
 232
 233         String primaryKey = UsageInstance.getPrimaryKey(usageId);
 234
 235         return getUsageInstanceArrayByKeyString(primaryKey);
 236     }
 237
 238     /**
 239        Get all PCD token for a usage instance according to primary key.
 240
 241        @param primaryKey    the primary key of usage instance.
 242
 243        @return List<UsageInstance>  the list contains all usage instances.
 244     **/
 245     public List<UsageInstance> getUsageInstanceArrayByKeyString(String primaryKey) {
 246         Token[]               tokenArray          = null;
 247         int                   recordIndex         = 0;
 248         UsageInstance         usageInstance       = null;
 249         List<UsageInstance>   returnArray         = new ArrayList<UsageInstance>();
 250
 251         tokenArray = getRecordArray();
 252
 253         //
 254         // Loop to find all PCD record related to current module
 255         //
 256         for (recordIndex = 0; recordIndex < getDBSize(); recordIndex++) {
 257             if (tokenArray[recordIndex].consumers.size() != 0) {
 258                 usageInstance = tokenArray[recordIndex].consumers.get(primaryKey);
 259                 if (usageInstance != null) {
 260                     returnArray.add(usageInstance);
 261                 }
 262             }
 263         }
 264
 265         return returnArray;
 266     }
 267
 268     /**
 269       Get all modules name who contains PCD information
 270
 271       @return Array for module name
 272     **/
 273     public List<String> getAllModuleArray()
 274     {
 275         int                       tokenIndex    = 0;
 276         int                       usageIndex    = 0;
 277         int                       moduleIndex   = 0;
 278         Token[]                   tokenArray    = null;
 279         Object[]                  usageInstanceArray = null;
 280         List<String>              moduleNames   = new ArrayList<String>();
 281         UsageInstance             usageInstance = null;
 282         boolean                   bFound        = false;
 283         String                    primaryKey    = null;
 284
 285         tokenArray = getRecordArray();
 286         //
 287         // Find all consumer usage instance for retrieving module's name
 288         //
 289         for (tokenIndex = 0; tokenIndex < getDBSize(); tokenIndex++) {
 290             usageInstanceArray = tokenArray[tokenIndex].consumers.entrySet().toArray();
 291             for (usageIndex = 0; usageIndex < tokenArray[tokenIndex].consumers.size(); usageIndex++) {
 292                 usageInstance = (UsageInstance)((Map.Entry)usageInstanceArray[usageIndex]).getValue();
 293                 primaryKey    = usageInstance.getPrimaryKey();
 294                 bFound        = false;
 295                 for (moduleIndex = 0; moduleIndex < moduleNames.size(); moduleIndex++) {
 296                     if (moduleNames.get(moduleIndex).equalsIgnoreCase(primaryKey)) {
 297                         bFound = true;
 298                         break;
 299                     }
 300                 }
 301                 if (!bFound) {
 302                     moduleNames.add(primaryKey);
 303                 }
 304             }
 305         }
 306         return moduleNames;
 307     }
 308 }