[mirror_edk2.git] / Tools / Source / GenBuild / org / tianocore / build / global / GlobalData.java

/** @file\r
  GlobalData class. \r
  \r
  GlobalData provide initializing, instoring, querying and update global data.\r
  It is a bridge to intercommunicate between multiple component, such as AutoGen,\r
  PCD and so on.   \r
 \r
Copyright (c) 2006, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
**/\r
package org.tianocore.build.global;\r
\r
import java.io.File;\r
import java.util.ArrayList;\r
import java.util.HashMap;\r
import java.util.HashSet;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Set;\r
\r
import org.apache.tools.ant.BuildException;\r
import org.apache.xmlbeans.XmlObject;\r
import org.tianocore.FilenameDocument;\r
import org.tianocore.FilenameDocument.Filename;\r
import org.tianocore.FrameworkDatabaseDocument;\r
import org.tianocore.MsaFilesDocument;\r
import org.tianocore.MsaFilesDocument.MsaFiles.MsaFile;\r
import org.tianocore.MsaHeaderDocument.MsaHeader;\r
import org.tianocore.MsaLibHeaderDocument.MsaLibHeader;\r
import org.tianocore.PackageListDocument;\r
import org.tianocore.PackageSurfaceAreaDocument;\r
import org.tianocore.build.autogen.CommonDefinition;\r
import org.tianocore.build.fpd.FpdParserTask;\r
import org.tianocore.build.pcd.entity.MemoryDatabaseManager;\r
\r
/**\r
  GlobalData provide initializing, instoring, querying and update global data.\r
  It is a bridge to intercommunicate between multiple component, such as AutoGen,\r
  PCD and so on. \r
  \r
  <p>Note that all global information are initialized incrementally. All data will \r
  parse and record only it is necessary during build time. </p>\r
  \r
  @since GenBuild 1.0\r
**/\r
public class GlobalData {\r
\r
    ///\r
    /// means no surface area information for module\r
    ///\r
    public static final int NO_SA = 0;\r
\r
    ///\r
    /// means only MSA\r
    ///\r
    public static final int ONLY_MSA = 1;\r
\r
    ///\r
    /// means only Library MSA\r
    ///\r
    public static final int ONLY_LIBMSA = 2;\r
\r
    ///\r
    /// means both MSA and MBD\r
    ///\r
    public static final int MSA_AND_MBD = 3;\r
\r
    ///\r
    /// means both Library MSA and Library MBD\r
    ///\r
    public static final int LIBMSA_AND_LIBMBD = 4;\r
\r
    ///\r
    /// Be used to ensure Global data will be initialized only once.\r
    ///\r
    public static boolean globalFlag = false;\r
\r
    ///\r
    /// Record current WORKSPACE Directory\r
    ///\r
    private static String workspaceDir = "";\r
\r
    ///\r
    /// Two columns: Package Name (Key), Package Path(ralative to WORKSPACE)\r
    ///\r
    private static final Map<String, String> packageInfo = new HashMap<String, String>();\r
\r
    ///\r
    /// spdTable\r
    /// Key: Package Name, Value: SPD detail info\r
    ///\r
    private static final Map<String, Spd> spdTable = new HashMap<String, Spd>();\r
\r
    ///\r
    /// Three columns:\r
    /// 1. Module Name | BaseName (Key)\r
    /// 2. Module Path + Msa file name (relative to Package)\r
    /// 3. Package Name (This module belong to which package)\r
    ///\r
    private static final Map<String, String[]> moduleInfo = new HashMap<String, String[]>();\r
\r
    ///\r
    /// List all libraries for current build module\r
    /// Key: Library BaseName, Value: output library path+name\r
    ///\r
    private static final Map<String, String> libraries = new HashMap<String, String>();\r
\r
    ///\r
    /// Store every module's relative library instances BaseName\r
    /// Key: Module BaseName, Value: All library instances module depends on.\r
    ///\r
    private static final Map<String, Set<String> > moduleLibraryMap = new HashMap<String, Set<String> >();\r
\r
    ///\r
    /// Key: Module BaseName, Value: original MSA info\r
    ///\r
    private static final Map<String, Map<String, XmlObject> > nativeMsa = new HashMap<String, Map<String, XmlObject> >();\r
\r
    ///\r
    /// Key: Module BaseName, Value: original MBD info\r
    ///\r
    private static final Map<String, Map<String, XmlObject> > nativeMbd = new HashMap<String, Map<String, XmlObject> >();\r
\r
    ///\r
    /// Two columns: Module Name or Base Name as Key\r
    /// Value is a HashMap with overridden data from MSA/MBD or/and Platform\r
    ///\r
    private static final Map<String, Map<String, XmlObject> > parsedModules = new HashMap<String, Map<String, XmlObject> >();\r
\r
    ///\r
    /// List all built Module; Value is Module BaseName + Arch. TBD\r
    ///\r
    private static final Set<String> builtModules = new HashSet<String>();\r
\r
    ///\r
    /// Library instance information table which recored the library and it's\r
    /// constructor and distructor function\r
    ///\r
    private static final Map<String, String[]> libInstanceInfo = new HashMap<String, String[]>();\r
\r
    ///\r
    /// PCD memory database stored all PCD information which collected from FPD,MSA and SPD.\r
    ///\r
    private static final MemoryDatabaseManager pcdDbManager = new MemoryDatabaseManager();\r
\r
    /**\r
      Query the module's absolute path with module base name. \r
      \r
      @param moduleName the base name of the module\r
      @return the absolute module path\r
    **/\r
    public synchronized static String getModulePath(String moduleName) {\r
        String[] info = moduleInfo.get(moduleName);\r
        String packagePath = (String) packageInfo.get(info[1]);\r
        File convertFile = new File(workspaceDir + File.separatorChar + packagePath + File.separatorChar + info[0]);\r
        return convertFile.getParent();\r
    }\r
\r
    /**\r
      Query the module's absolute MSA file path with module base name. \r
    \r
      @param moduleName the base name of the module\r
      @return the absolute MSA file name\r
      @throws BuildException\r
              Base name is not registered in any SPD files\r
    **/\r
    private synchronized static String getMsaFilename(String moduleName) throws BuildException {\r
        String[] info = moduleInfo.get(moduleName);\r
        if (info == null) {\r
            throw new BuildException("Module base name [" + moduleName + "] can't found in all SPD.");\r
        }\r
        String packagePath = (String) packageInfo.get(info[1]);\r
        File convertFile = new File(workspaceDir + File.separatorChar + packagePath + File.separatorChar + info[0]);\r
        return convertFile.getPath();\r
    }\r
\r
    /**\r
      Query the module's absolute MBD file path with module base name. \r
    \r
      @param moduleName the base name of the module\r
      @return the absolute MBD file name\r
      @throws BuildException\r
              Base name is not registered in any SPD files\r
    **/\r
    private synchronized static String getMbdFilename(String moduleName) throws BuildException {\r
        String[] info = moduleInfo.get(moduleName);\r
        if (info == null) {\r
            throw new BuildException("Info: Module base name [" + moduleName + "] can't found in all SPD.");\r
        }\r
        String packagePath = (String) packageInfo.get(info[1]);\r
        File convertFile = new File(workspaceDir + File.separatorChar + packagePath + File.separatorChar + info[0]);\r
        return convertFile.getPath().substring(0, convertFile.getPath().length() - 4) + ".mbd";\r
    }\r
\r
    /**\r
      Get the current WORKSPACE Directory. \r
      @return current workspace directory\r
    **/\r
    public synchronized static String getWorkspacePath() {\r
        return workspaceDir;\r
    }\r
\r
    /**\r
      Query package relative path to WORKSPACE_DIR with package name. \r
      \r
      @param packageName the name of the package\r
      @return the path relative to WORKSPACE_DIR \r
    **/\r
    public synchronized static String getPackagePath(String packageName) {\r
        return (String) packageInfo.get(packageName);\r
    }\r
\r
    /**\r
      Query package (which the module belongs to) relative path to WORSPACE_DIR.  \r
    \r
      @param moduleName the base name of the module\r
      @return the relative path to WORKSPACE_DIR of the package which the module belongs to\r
    **/\r
    public synchronized static String getPackagePathForModule(String moduleName) {\r
        String[] info = moduleInfo.get(moduleName);\r
        String packagePath = (String) packageInfo.get(info[1]);\r
        return packagePath;\r
    }\r
\r
    /**\r
      Query the package name which the module belongs to with the module's base name.\r
    \r
      @param moduleName the base name of the module\r
      @return the package name which the module belongs to\r
    **/\r
    public synchronized static String getPackageNameForModule(String moduleName) {\r
        return moduleInfo.get(moduleName)[1];\r
    }\r
\r
    /**\r
      Parse framework database (DB) and all SPD files listed in DB to initialize\r
      the environment for next build. This method will only be executed only once\r
      in the whole build process.  \r
      \r
      @param workspaceDatabaseFile the file name of framework database\r
      @param workspaceDir current workspace directory path\r
      @throws BuildException\r
              Framework Dababase or SPD or MSA file is not valid\r
    **/\r
    public synchronized static void initInfo(String workspaceDatabaseFile, String workspaceDir) throws BuildException {\r
        if (globalFlag) {\r
            return;\r
        }\r
        globalFlag = true;\r
        GlobalData.workspaceDir = workspaceDir;\r
        File dbFile = new File(workspaceDir + File.separatorChar + workspaceDatabaseFile);\r
        try {\r
            FrameworkDatabaseDocument db = (FrameworkDatabaseDocument) XmlObject.Factory.parse(dbFile);\r
            List<PackageListDocument.PackageList.Package> packages = db.getFrameworkDatabase().getPackageList()\r
                                                                       .getPackageList();\r
            Iterator iter = packages.iterator();\r
            while (iter.hasNext()) {\r
                PackageListDocument.PackageList.Package packageItem = (PackageListDocument.PackageList.Package) iter\r
                                                                                                                    .next();\r
                String name = packageItem.getPackageNameArray(0).getStringValue();\r
                String path = packageItem.getPathArray(0).getStringValue();\r
                packageInfo.put(name, path);\r
                File spdFile = new File(workspaceDir + File.separatorChar + path + File.separatorChar + name + ".spd");\r
                initPackageInfo(spdFile.getPath(), name);\r
                // \r
                // SPD Parse.\r
                //\r
                PackageSurfaceAreaDocument spdDoc = (PackageSurfaceAreaDocument) XmlObject.Factory.parse(spdFile);\r
                Spd spd = new Spd(spdDoc, path);\r
                spdTable.put(name, spd);\r
\r
            }\r
        } catch (Exception e) {\r
            throw new BuildException("Parse workspace Database [" + dbFile.getPath() + "] Error.\n" + e.getMessage());\r
        }\r
    }\r
\r
    /**\r
      Parse every MSA files, get base name from MSA Header. And record those\r
      values to ModuleInfo.\r
      \r
      @param packageFilename the file name of the package\r
      @param packageName the name of the package\r
      @throws BuildException\r
              SPD or MSA file is not valid\r
    **/\r
    private synchronized static void initPackageInfo(String packageFilename, String packageName) throws BuildException {\r
        File packageFile = new File(packageFilename);\r
        try {\r
            PackageSurfaceAreaDocument spd = (PackageSurfaceAreaDocument) XmlObject.Factory.parse(packageFile);\r
            List<FilenameDocument.Filename> msaFilenameList;\r
\r
            List<MsaFilesDocument.MsaFiles.MsaFile> msasList = spd.getPackageSurfaceArea().getMsaFiles()\r
                                                                  .getMsaFileList();\r
            if (msasList.size() == 0) {\r
                msaFilenameList = spd.getPackageSurfaceArea().getMsaFiles().getFilenameList();\r
            } else {\r
                msaFilenameList = new ArrayList<FilenameDocument.Filename>(msasList.size());\r
                Iterator msasIter = msasList.iterator();\r
                while (msasIter.hasNext()) {\r
                    MsaFilesDocument.MsaFiles.MsaFile msaFile = (MsaFilesDocument.MsaFiles.MsaFile)msasIter.next();\r
                    msaFilenameList.add(msaFile.getFilename());\r
                }\r
            }\r
\r
            Iterator msaFilenameIter = msaFilenameList.iterator();\r
            while (msaFilenameIter.hasNext()) {\r
                FilenameDocument.Filename msaFilename = (FilenameDocument.Filename)msaFilenameIter.next();\r
                String filename = msaFilename.getStringValue();\r
                File msaFile = new File(workspaceDir + File.separatorChar + GlobalData.getPackagePath(packageName)\r
                                        + File.separatorChar + filename);\r
                SurfaceAreaParser surfaceAreaParser = new SurfaceAreaParser();\r
                Map<String, XmlObject> map = surfaceAreaParser.parseFile(msaFile);\r
                String baseName = "";\r
                XmlObject header = null;\r
                if ((header = map.get("MsaHeader")) != null) {\r
                    if (((MsaHeader) header).isSetBaseName()) {\r
                        baseName = ((MsaHeader) header).getBaseName().getStringValue();\r
                    } else {\r
                        baseName = ((MsaHeader) header).getModuleName();\r
                    }\r
                } else if ((header = map.get("MsaLibHeader")) != null) {\r
                    baseName = ((MsaLibHeader) header).getBaseName().getStringValue();\r
                } else {\r
                    continue;\r
                }\r
                nativeMsa.put(baseName, map);\r
                String[] info = { filename, packageName };\r
                moduleInfo.put(baseName, info);\r
            }\r
        } catch (Exception e) {\r
            throw new BuildException("Parse package description file [" + packageFile.getPath() + "] Error.\n"\r
                                     + e.getMessage());\r
        }\r
    }\r
\r
    /**\r
      Query the libraries which the module depends on.\r
    \r
      @param moduleName the base name of the module\r
      @return the libraries which the module depends on\r
    **/\r
    public synchronized static String[] getModuleLibrary(String moduleName, String arch) {\r
        Set<String> set = moduleLibraryMap.get(moduleName + "-" + arch);\r
        return set.toArray(new String[set.size()]);\r
    }\r
\r
    /**\r
      Register module's library list which it depends on for later use. \r
      \r
      @param moduleName the base name of the module\r
      @param libraryList the libraries which the module depends on\r
    **/\r
    public synchronized static void addModuleLibrary(String moduleName, String arch, Set<String> libraryList) {\r
        moduleLibraryMap.put(moduleName + "-" + arch, libraryList);\r
    }\r
\r
    /**\r
      Query the library absolute file name with library name. \r
      \r
      @param library the base name of the library\r
      @return the library absolute file name\r
    **/\r
    public synchronized static String getLibrary(String library, String arch) {\r
        return libraries.get(library + "-" + arch);\r
    }\r
\r
    /**\r
      Register library absolute file name for later use.\r
      \r
      @param library the base name of the library\r
      @param resultPath the library absolute file name\r
    **/\r
    public synchronized static void addLibrary(String library, String arch, String resultPath) {\r
        libraries.put(library + "-" + arch, resultPath);\r
    }\r
\r
    /**\r
      Whether the module with ARCH has built in the previous build. \r
      \r
      @param moduleName the base name of the module\r
      @param arch current build ARCH\r
      @return true if the module has built in previous, otherwise return false\r
    **/\r
    public synchronized static boolean isModuleBuilt(String moduleName, String arch) {\r
        return builtModules.contains(moduleName + "-" + arch);\r
    }\r
\r
    /**\r
      Register the module with ARCH has built. \r
    \r
      @param moduleName the base name of the module\r
      @param arch current build ARCH\r
    **/\r
    public synchronized static void registerBuiltModule(String moduleName, String arch) {\r
        builtModules.add(moduleName + "-" + arch);\r
    }\r
\r
    /**\r
      Whether the module's surface area has parsed in the previous build.\r
      \r
      @param moduleName the base name of the module\r
      @return true if the module's surface area has parsed in previous, otherwise\r
      return false\r
    **/\r
    public synchronized static boolean isModuleParsed(String moduleName) {\r
        return parsedModules.containsKey(moduleName);\r
    }\r
\r
    /**\r
      Query overrided module surface area information. If current is Package\r
      or Platform build, also include the information from FPD file. \r
      \r
      <p>Note that surface area parsing is incremental. That means the method will \r
      only to parse the MSA and MBD files when never parsed before. </p>\r
    \r
      @param moduleName the base name of the module\r
      @return the overrided module surface area information\r
      @throws BuildException\r
              MSA or MBD is not valid\r
    **/\r
    public synchronized static Map<String, XmlObject> getDoc(String moduleName) throws BuildException {\r
        if (parsedModules.containsKey(moduleName)) {\r
            return parsedModules.get(moduleName);\r
        }\r
        Map<String, XmlObject> msaMap = getNativeMsa(moduleName);\r
        Map<String, XmlObject> mbdMap = getNativeMbd(moduleName);\r
        OverrideProcess op = new OverrideProcess();\r
        Map<String, XmlObject> map = op.override(mbdMap, msaMap);\r
        //\r
        // IF IT IS A PALTFORM BUILD, OVERRIDE FROM PLATFORM\r
        //\r
        if (FpdParserTask.platformBuildOptions != null) {\r
            Map<String, XmlObject> platformMap = new HashMap<String, XmlObject>();\r
            platformMap.put("BuildOptions", FpdParserTask.platformBuildOptions);\r
            Map<String, XmlObject> overrideMap = op.override(platformMap, OverrideProcess.deal(map));\r
            GlobalData.registerModule(moduleName, overrideMap);\r
            return overrideMap;\r
        } else {\r
            parsedModules.put(moduleName, map);\r
            return map;\r
        }\r
    }\r
\r
    /**\r
      Query the native MSA information with module base name. \r
      \r
      <p>Note that MSA parsing is incremental. That means the method will \r
      only to parse the MSA files when never parsed before. </p>\r
      \r
      @param moduleName the base name of the module\r
      @return the native MSA information\r
      @throws BuildException\r
              MSA file is not valid\r
    **/\r
    public synchronized static Map<String, XmlObject> getNativeMsa(String moduleName) throws BuildException {\r
        if (nativeMsa.containsKey(moduleName)) {\r
            return nativeMsa.get(moduleName);\r
        }\r
        String msaFilename = getMsaFilename(moduleName);\r
        File msaFile = new File(msaFilename);\r
        if (!msaFile.exists()) {\r
            throw new BuildException("Info: Surface Area file [" + msaFile.getPath() + "] can't found.");\r
        }\r
        SurfaceAreaParser surfaceAreaParser = new SurfaceAreaParser();\r
        Map<String, XmlObject> map = surfaceAreaParser.parseFile(msaFile);\r
        nativeMsa.put(moduleName, map);\r
        return map;\r
    }\r
    \r
    /**\r
      Query the native MBD information with module base name. \r
      \r
      <p>Note that MBD parsing is incremental. That means the method will \r
      only to parse the MBD files when never parsed before. </p>\r
    \r
      @param moduleName the base name of the module\r
      @return the native MBD information\r
      @throws BuildException\r
              MBD file is not valid\r
    **/\r
    public synchronized static Map<String, XmlObject> getNativeMbd(String moduleName) throws BuildException {\r
        if (nativeMbd.containsKey(moduleName)) {\r
            return nativeMbd.get(moduleName);\r
        }\r
        String mbdFilename = getMbdFilename(moduleName);\r
        File mbdFile = new File(mbdFilename);\r
        if (!mbdFile.exists()) {\r
            return null;\r
            //throw new BuildException("Info: Surface Area file [" + mbdFile.getPath() + "] can't found.");\r
        }\r
        SurfaceAreaParser surfaceAreaParser = new SurfaceAreaParser();\r
        Map<String, XmlObject> map = surfaceAreaParser.parseFile(mbdFile);\r
        nativeMbd.put(moduleName, map);\r
        return map;\r
    }\r
\r
    /**\r
      Register module overrided surface area information. If has existed, then update.\r
      \r
      @param moduleName the base name of the module\r
      @param map the overrided surface area information\r
    **/\r
    public synchronized static void registerModule(String moduleName, Map<String, XmlObject> map) {\r
        parsedModules.put(moduleName, map);\r
    }\r
\r
    /**\r
     * \r
     * @param protocolName\r
     * @return\r
     */\r
    public synchronized static String[] getProtocolInfoGuid(String protocolName) {\r
        Set set = spdTable.keySet();\r
        Iterator iter = set.iterator();\r
        String[] cNameGuid = null;\r
\r
        while (iter.hasNext()) {\r
            Spd spd = (Spd) spdTable.get(iter.next());\r
            cNameGuid = spd.getProtocolNameGuidArray(protocolName);\r
            if (cNameGuid != null) {\r
                break;\r
            }\r
        }\r
        return cNameGuid;\r
    }\r
\r
    public synchronized static String[] getPpiInfoGuid(String ppiName) {\r
        Set set = spdTable.keySet();\r
        Iterator iter = set.iterator();\r
        String[] cNameGuid = null;\r
\r
        while (iter.hasNext()) {\r
            Spd spd = (Spd) spdTable.get(iter.next());\r
            cNameGuid = spd.getPpiCnameGuidArray(ppiName);\r
\r
            if (cNameGuid != null) {\r
                break;\r
            }\r
        }\r
        return cNameGuid;\r
    }\r
\r
    /**\r
     * \r
     * @param guidName\r
     * @return\r
     */\r
    public synchronized static String[] getGuidInfoGuid(String guidName) {\r
        String[] cNameGuid = null;\r
        Set set = spdTable.keySet();\r
        Iterator iter = set.iterator();\r
\r
        while (iter.hasNext()) {\r
            Spd spd = (Spd) spdTable.get(iter.next());\r
            cNameGuid = spd.getGuidNameArray(guidName);\r
            if (cNameGuid != null) {\r
                break;\r
            }\r
        }\r
        return cNameGuid;\r
    }\r
\r
    public synchronized static String getLibClassIncluder(String libName) {\r
        String libIncluder = null;\r
        Set set = spdTable.keySet();\r
        Iterator iter = set.iterator();\r
\r
        while (iter.hasNext()) {\r
            String packageName = (String) iter.next();\r
            Spd spd = (Spd) spdTable.get(packageName);\r
            libIncluder = spd.getLibClassIncluder(libName);\r
            String packagePath = spd.packagePath;\r
            if (packagePath != null) {\r
                packagePath = packagePath.replace('\\', File.separatorChar);\r
                packagePath = packagePath.replace('/', File.separatorChar);\r
            } else {\r
                packagePath = packageName;\r
            }\r
            if (libIncluder != null) {\r
                libIncluder = libIncluder.replace('\\', File.separatorChar);\r
                libIncluder = libIncluder.replace('/', File.separatorChar);\r
                libIncluder = packageName + File.separatorChar + libIncluder;\r
                break;\r
            }\r
        }\r
        return libIncluder;\r
    }\r
\r
    public synchronized static String getModuleInfoByPackageName(String packageName, String moduleType) {\r
        Spd spd;\r
        String includeFile = null;\r
        String includeStr = "";\r
        String cleanPath = "";\r
\r
        spd = (Spd) spdTable.get(packageName);\r
        includeFile = spd.getModuleTypeIncluder(moduleType);\r
        if (includeFile != null) {\r
            includeFile = includeFile.replace('\\', File.separatorChar);\r
            includeFile = includeFile.replace('/', File.separatorChar);\r
            includeStr = CommonDefinition.include + " <" + includeStr;\r
            cleanPath = spd.packagePath;\r
            cleanPath = cleanPath.replace('\\', File.separatorChar);\r
            cleanPath = cleanPath.replace('/', File.separatorChar);\r
\r
            if (cleanPath.charAt(spd.packagePath.length() - 1) != File.separatorChar) {\r
                cleanPath = cleanPath + File.separatorChar;\r
            }\r
            includeStr = includeStr + cleanPath;\r
            includeStr = includeStr + includeFile;\r
            includeStr = includeStr + ">\r\n";\r
        }\r
\r
        return includeStr;\r
    }\r
\r
    public synchronized static void setLibInstanceInfo(String libName, String libConstructor, String libDesturctor) {\r
        String[] libConsDes = new String[2];\r
        libConsDes[0] = libConstructor;\r
        libConsDes[1] = libDesturctor;\r
\r
        libInstanceInfo.put(libName, libConsDes);\r
    }\r
\r
    public synchronized static boolean isHaveLibInstance(String libName) {\r
        return libInstanceInfo.containsKey(libName);\r
    }\r
\r
    public synchronized static String getLibInstanceConstructor(String libName) {\r
        String[] libInstanceValue;\r
        libInstanceValue = libInstanceInfo.get(libName);\r
        if (libInstanceValue != null) {\r
            return libInstanceValue[0];\r
        } else {\r
            return null;\r
        }\r
    }\r
\r
    public synchronized static String getLibInstanceDestructor(String libName) {\r
        String[] libInstanceValue;\r
        libInstanceValue = libInstanceInfo.get(libName);\r
        if (libInstanceValue != null) {\r
            return libInstanceValue[1];\r
        } else {\r
            return null;\r
        }\r
    }\r
\r
    public synchronized static MemoryDatabaseManager getPCDMemoryDBManager() {\r
        return pcdDbManager;\r
    }\r
}\r