Tools/Source/PackageEditor/src/org/tianocore/packaging/SpdFileContents.java

   1 /** @file
   2   Java class SpdFileContents is used to parse spd xml file.
   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 package org.tianocore.packaging;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.util.List;
  18 import java.util.ListIterator;
  19 import java.math.*;
  20 import org.apache.xmlbeans.XmlObject;
  21 import org.apache.xmlbeans.XmlOptions;
  22 import org.apache.xmlbeans.XmlCursor;
  23
  24 import org.tianocore.AbstractDocument;
  25 import org.tianocore.GuidDeclarationsDocument;
  26 import org.tianocore.GuidDocument;
  27 import org.tianocore.IncludeHeaderDocument;
  28 import org.tianocore.LibraryClassDeclarationDocument;
  29 import org.tianocore.LibraryClassDeclarationsDocument;
  30 import org.tianocore.LibraryClassDocument;
  31 import org.tianocore.LibraryUsage;
  32 import org.tianocore.LicenseDocument;
  33 import org.tianocore.ModuleTypeDef;
  34 import org.tianocore.MsaFilesDocument;
  35 import org.tianocore.OutputDirectoryDocument;
  36 import org.tianocore.PackageDependenciesDocument;
  37 import org.tianocore.PackageHeadersDocument;
  38 import org.tianocore.PackageNameDocument;
  39 import org.tianocore.PackageSurfaceAreaDocument;
  40 import org.tianocore.PackageType;
  41 import org.tianocore.PackageUsage;
  42 import org.tianocore.PcdDataTypes;
  43 import org.tianocore.PcdDefinitionsDocument;
  44 import org.tianocore.PcdItemTypes;
  45 import org.tianocore.PpiDeclarationsDocument;
  46 import org.tianocore.ProtocolDeclarationsDocument;
  47 import org.tianocore.SpdHeaderDocument;
  48 import org.tianocore.SpecificationDocument;
  49 import org.tianocore.GuidDeclarationsDocument.GuidDeclarations;
  50
  51 /**
  52  This class processes spd file contents such as add remove xml elements.
  53
  54  @since PackageEditor 1.0
  55 **/
  56 public class SpdFileContents {
  57
  58     private File file = null;
  59
  60     private PackageSurfaceAreaDocument psad = null;
  61
  62     private PackageSurfaceAreaDocument.PackageSurfaceArea psaRoot = null;
  63
  64     private SpdHeaderDocument.SpdHeader spdHdr = null;
  65
  66     private String spdHdrPkgName = null;
  67
  68     private GuidDocument.Guid spdHdrGuid = null;
  69
  70     private AbstractDocument.Abstract spdHdrAbs = null;
  71
  72     private LicenseDocument.License spdHdrLicense = null;
  73
  74     private SpecificationDocument.Specification spdHdrSpec = null;
  75
  76     private OutputDirectoryDocument.OutputDirectory spdHdrOutDir = null;
  77
  78     private LibraryClassDeclarationsDocument.LibraryClassDeclarations spdLibClassDeclarations = null;
  79
  80     private PackageDependenciesDocument.PackageDependencies spdPkgDeps = null;
  81
  82     private MsaFilesDocument.MsaFiles spdMsaFiles = null;
  83
  84     private PackageHeadersDocument.PackageHeaders spdModHdrs = null;
  85
  86     private GuidDeclarationsDocument.GuidDeclarations spdGuidDeclarations = null;
  87
  88     private ProtocolDeclarationsDocument.ProtocolDeclarations spdProtocolDeclarations = null;
  89
  90     private PpiDeclarationsDocument.PpiDeclarations spdPpiDeclarations = null;
  91
  92     private PcdDefinitionsDocument.PcdDefinitions spdPcdDefinitions = null;
  93
  94     /**
  95      Constructor to create a new spd file
  96     **/
  97     public SpdFileContents() {
  98
  99         psad = PackageSurfaceAreaDocument.Factory.newInstance();
 100         psaRoot = psad.addNewPackageSurfaceArea();
 101
 102     }
 103
 104     /**
 105      Constructor based on an existing spd file
 106
 107      @param f Existing spd file
 108     **/
 109     public SpdFileContents(File f) {
 110         try {
 111             psad = PackageSurfaceAreaDocument.Factory.parse(f);
 112             psaRoot = psad.getPackageSurfaceArea();
 113             file = f;
 114         } catch (Exception e) {
 115             System.out.println(e.toString());
 116         }
 117     }
 118
 119     /**
 120      Remove existing pcd definitions elements using XmlCursor
 121     **/
 122     public void removeSpdPcdDefinition() {
 123         XmlObject o = psaRoot.getPcdDefinitions();
 124         if (o == null)
 125             return;
 126         XmlCursor cursor = o.newCursor();
 127         cursor.removeXml();
 128         spdPcdDefinitions = null;
 129     }
 130
 131     /**
 132      Remove existing ppi declarations using XmlCursor
 133     **/
 134     public void removeSpdPpiDeclaration() {
 135         XmlObject o = psaRoot.getPpiDeclarations();
 136         if (o == null)
 137             return;
 138         XmlCursor cursor = o.newCursor();
 139         cursor.removeXml();
 140         spdPpiDeclarations = null;
 141     }
 142
 143     /**
 144      Remove existing protocols declarations using XmlCursor
 145     **/
 146     public void removeSpdProtocolDeclaration() {
 147         XmlObject o = psaRoot.getProtocolDeclarations();
 148         if (o == null)
 149             return;
 150         XmlCursor cursor = o.newCursor();
 151         cursor.removeXml();
 152         spdProtocolDeclarations = null;
 153     }
 154
 155     /**
 156      Remove existing GUID declarations using XmlCursor
 157     **/
 158     public void removeSpdGuidDeclaration() {
 159         XmlObject o = psaRoot.getGuidDeclarations();
 160         if (o == null)
 161             return;
 162         XmlCursor cursor = o.newCursor();
 163         cursor.removeXml();
 164         spdGuidDeclarations = null;
 165     }
 166
 167     /**
 168      Remove existing spd package include files using XmlCursor
 169     **/
 170     public void removeSpdPkgHeader() {
 171         XmlObject o = psaRoot.getPackageHeaders();
 172         if (o == null)
 173             return;
 174         XmlCursor cursor = o.newCursor();
 175         cursor.removeXml();
 176         spdModHdrs = null;
 177     }
 178
 179     /**
 180      Remove existing msa files using XmlCursor
 181     **/
 182     public void removeSpdMsaFile() {
 183         XmlObject o = psaRoot.getMsaFiles();
 184         if (o == null)
 185             return;
 186         XmlCursor cursor = o.newCursor();
 187         cursor.removeXml();
 188         spdMsaFiles = null;
 189     }
 190
 191     /**
 192      Remove existing library class declarations using XmlCursor
 193     **/
 194     public void removeSpdLibClass() {
 195         XmlObject o = psaRoot.getLibraryClassDeclarations();
 196         if (o == null)
 197             return;
 198         XmlCursor cursor = o.newCursor();
 199         cursor.removeXml();
 200         spdLibClassDeclarations = null;
 201     }
 202
 203     /**
 204      Get spd file header contents into String array
 205
 206      @param s Caller allocated String array
 207     **/
 208     public void getSpdHdrDetails(String[] s) {
 209         if (getSpdHdr() == null) {
 210             spdHdr = psaRoot.addNewSpdHeader();
 211         }
 212         s[0] = getSpdHdrPkgName();
 213         s[1] = getSpdHdrGuid().getStringValue();
 214         s[2] = getSpdHdrVer();
 215         s[3] = getSpdHdrAbs().getStringValue();
 216         s[4] = getSpdHdr().getDescription();
 217         s[5] = getSpdHdr().getCopyright();
 218         s[6] = getSpdHdrLicense().getStringValue();
 219         s[7] = getSpdHdr().getCreated();
 220         s[8] = getSpdHdr().getURL();
 221         if (getSpdHdr().getPackageType() != null) {
 222             s[9] = getSpdHdr().getPackageType().toString();
 223         }
 224         //
 225         // convert boolean to String by adding empty String ""
 226         //
 227         s[10] = getSpdHdr().getReadOnly() + "";
 228         s[11] = getSpdHdr().getReadOnly() + "";
 229     }
 230
 231     /**
 232      Get the number of library class declarations from the size of List
 233
 234      @return int
 235     **/
 236     public int getSpdLibClassDeclarationCount() {
 237         if (psaRoot.getLibraryClassDeclarations() == null
 238             || psaRoot.getLibraryClassDeclarations().getLibraryClassDeclarationList() == null) {
 239             return 0;
 240         }
 241         return psaRoot.getLibraryClassDeclarations().getLibraryClassDeclarationList().size();
 242     }
 243
 244     /**
 245      Get available library class declaration into String array
 246      @param libClass Caller allocated two-dimentional String array
 247     **/
 248     public void getSpdLibClassDeclarations(String[][] libClass) {
 249         List<LibraryClassDeclarationDocument.LibraryClassDeclaration> l = psaRoot.getLibraryClassDeclarations()
 250                                                                                  .getLibraryClassDeclarationList();
 251         int i = 0;
 252         ListIterator li = l.listIterator();
 253         while (li.hasNext()) {
 254             LibraryClassDeclarationDocument.LibraryClassDeclaration lcd = (LibraryClassDeclarationDocument.LibraryClassDeclaration) li
 255                                                                                                                                       .next();
 256             if (lcd.getLibraryClass() != null) {
 257                 libClass[i][0] = lcd.getLibraryClass().getStringValue();
 258             }
 259             if (lcd.getIncludeHeader() != null) {
 260                 libClass[i][1] = lcd.getIncludeHeader().getStringValue();
 261             }
 262
 263             i++;
 264         }
 265
 266     }
 267
 268     /**
 269     Get the number of Msa files from the size of List
 270
 271     @return int
 272    **/
 273     public int getSpdMsaFileCount() {
 274         if (psaRoot.getMsaFiles() == null || psaRoot.getMsaFiles().getMsaFileList() == null) {
 275             return 0;
 276         }
 277         return psaRoot.getMsaFiles().getMsaFileList().size();
 278     }
 279
 280     /**
 281     Get available Msa file into String array
 282
 283     @param msaFile Caller allocated two-dimentional String array
 284    **/
 285     public void getSpdMsaFiles(String[][] msaFile) {
 286         List<MsaFilesDocument.MsaFiles.MsaFile> l = psaRoot.getMsaFiles().getMsaFileList();
 287         int i = 0;
 288         ListIterator li = l.listIterator();
 289         while (li.hasNext()) {
 290             MsaFilesDocument.MsaFiles.MsaFile m = (MsaFilesDocument.MsaFiles.MsaFile) li.next();
 291             if (m.getFilename() != null) {
 292                 msaFile[i][0] = m.getFilename().getStringValue();
 293             }
 294
 295             i++;
 296         }
 297     }
 298
 299     /**
 300     Get the number of include header files in PackageHeaders from the size of List
 301
 302     @return int
 303    **/
 304     public int getSpdPackageHeaderCount() {
 305         if (psaRoot.getPackageHeaders() == null || psaRoot.getPackageHeaders().getIncludeHeaderList() == null) {
 306             return 0;
 307         }
 308         return psaRoot.getPackageHeaders().getIncludeHeaderList().size();
 309     }
 310
 311     /**
 312     Get available package header contents into String array
 313
 314     @param pkgHeader Caller allocated two-dimentional String array
 315    **/
 316     public void getSpdPackageHeaders(String[][] pkgHeader) {
 317         List<IncludeHeaderDocument.IncludeHeader> l = psaRoot.getPackageHeaders().getIncludeHeaderList();
 318         int i = 0;
 319         ListIterator li = l.listIterator();
 320         while (li.hasNext()) {
 321             IncludeHeaderDocument.IncludeHeader ih = (IncludeHeaderDocument.IncludeHeader) li.next();
 322             if (ih.getModuleType() != null) {
 323                 pkgHeader[i][0] = ih.getModuleType().toString();
 324             }
 325
 326             pkgHeader[i][1] = ih.getStringValue();
 327             i++;
 328         }
 329     }
 330
 331     /**
 332     Get the number of GUID declarations from the size of List
 333
 334     @return int
 335    **/
 336     public int getSpdGuidDeclarationCount() {
 337         if (psaRoot.getGuidDeclarations() == null || psaRoot.getGuidDeclarations().getEntryList() == null) {
 338             return 0;
 339         }
 340         return psaRoot.getGuidDeclarations().getEntryList().size();
 341     }
 342
 343     /**
 344     Get available Guid declaration contents into String array
 345
 346     @param guid Caller allocated two-dimentional String array
 347    **/
 348     public void getSpdGuidDeclarations(String[][] guid) {
 349         List<GuidDeclarationsDocument.GuidDeclarations.Entry> l = psaRoot.getGuidDeclarations().getEntryList();
 350         int i = 0;
 351         ListIterator li = l.listIterator();
 352         while (li.hasNext()) {
 353             GuidDeclarationsDocument.GuidDeclarations.Entry e = (GuidDeclarationsDocument.GuidDeclarations.Entry) li
 354                                                                                                                     .next();
 355             guid[i][0] = e.getName();
 356             guid[i][1] = e.getCName();
 357             if (e.getGuid() != null) {
 358                 guid[i][2] = e.getGuid().getStringValue();
 359             }
 360             i++;
 361         }
 362     }
 363
 364     /**
 365     Get the number of protocol declarations from the size of List
 366
 367     @return int
 368    **/
 369     public int getSpdProtocolDeclarationCount() {
 370         if (psaRoot.getProtocolDeclarations() == null || psaRoot.getProtocolDeclarations().getEntryList() == null) {
 371             return 0;
 372         }
 373         return psaRoot.getProtocolDeclarations().getEntryList().size();
 374     }
 375
 376     /**
 377     Get available protocol declaration contents into String array
 378
 379     @param protocol Caller allocated two-dimentional String array
 380    **/
 381     public void getSpdProtocolDeclarations(String[][] protocol) {
 382         List<ProtocolDeclarationsDocument.ProtocolDeclarations.Entry> l = psaRoot.getProtocolDeclarations()
 383                                                                                  .getEntryList();
 384         int i = 0;
 385         ListIterator li = l.listIterator();
 386         while (li.hasNext()) {
 387             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry e = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry) li
 388                                                                                                                                     .next();
 389             protocol[i][0] = e.getName();
 390             protocol[i][1] = e.getCName();
 391             if (e.getGuid() != null) {
 392                 protocol[i][2] = e.getGuid().getStringValue();
 393             }
 394             i++;
 395         }
 396     }
 397
 398     /**
 399     Get the number of Ppi declarations from the size of List
 400
 401     @return int
 402    **/
 403     public int getSpdPpiDeclarationCount() {
 404         if (psaRoot.getPpiDeclarations() == null || psaRoot.getPpiDeclarations().getEntryList() == null) {
 405             return 0;
 406         }
 407         return psaRoot.getPpiDeclarations().getEntryList().size();
 408     }
 409
 410     /**
 411     Get available Ppi declaration contents into String array
 412
 413     @param ppi Caller allocated two-dimentional String array
 414    **/
 415     public void getSpdPpiDeclarations(String[][] ppi) {
 416         List<PpiDeclarationsDocument.PpiDeclarations.Entry> l = psaRoot.getPpiDeclarations().getEntryList();
 417         int i = 0;
 418         ListIterator li = l.listIterator();
 419         while (li.hasNext()) {
 420             PpiDeclarationsDocument.PpiDeclarations.Entry e = (PpiDeclarationsDocument.PpiDeclarations.Entry) li.next();
 421             ppi[i][0] = e.getName();
 422             ppi[i][1] = e.getCName();
 423             if (e.getGuid() != null) {
 424                 ppi[i][2] = e.getGuid().getStringValue();
 425             }
 426
 427             i++;
 428         }
 429     }
 430
 431     /**
 432     Get the number of Pcd definitions from the size of List
 433
 434     @return int
 435    **/
 436     public int getSpdPcdDefinitionCount() {
 437         if (psaRoot.getPcdDefinitions() == null || psaRoot.getPcdDefinitions().getPcdEntryList() == null) {
 438             return 0;
 439         }
 440         return psaRoot.getPcdDefinitions().getPcdEntryList().size();
 441     }
 442
 443     /**
 444     Get available Pcd definition contents into String array
 445
 446     @param pcd Caller allocated two-dimentional String array
 447    **/
 448     public void getSpdPcdDefinitions(String[][] pcd) {
 449         List<PcdDefinitionsDocument.PcdDefinitions.PcdEntry> l = psaRoot.getPcdDefinitions().getPcdEntryList();
 450         int i = 0;
 451         ListIterator li = l.listIterator();
 452         while (li.hasNext()) {
 453             PcdDefinitionsDocument.PcdDefinitions.PcdEntry e = (PcdDefinitionsDocument.PcdDefinitions.PcdEntry) li
 454                                                                                                                   .next();
 455             if (e.getItemType() != null) {
 456                 pcd[i][0] = e.getItemType().toString();
 457             }
 458
 459             pcd[i][1] = e.getCName();
 460             pcd[i][2] = e.getToken();
 461             if (e.getDatumType() != null) {
 462                 pcd[i][3] = e.getDatumType().toString();
 463             }
 464
 465             if (e.getDefaultValue() != null) {
 466                 pcd[i][4] = e.getDefaultValue().toString();
 467             }
 468
 469             i++;
 470         }
 471     }
 472
 473     /**
 474      Save the processed xml contents to file
 475
 476      @param spdFile The file to save xml contents
 477      @throws IOException Exceptions during file operation
 478     **/
 479     public void saveAs(File spdFile) throws IOException {
 480
 481         XmlOptions options = new XmlOptions();
 482
 483         options.setCharacterEncoding("UTF-8");
 484         options.setSavePrettyPrint();
 485         options.setSavePrettyPrintIndent(2);
 486         try {
 487             psad.save(spdFile, options);
 488         } catch (IOException e) {
 489             e.printStackTrace();
 490         }
 491
 492     }
 493
 494     /**
 495      Generate SpdHeader contents using parameters passed in.
 496
 497      @param pkgName PackageName
 498      @param pkgGuid Guid
 499      @param pkgVer Version
 500      @param pkgAbs Abstract
 501      @param pkgDes Description
 502      @param pkgCpRight Copyright
 503      @param pkgLicense License
 504      @param pkgCreateDate Created
 505      @param pkgUpdateDate Updated
 506      @param pkgURL URL
 507      @param pkgType PackageType
 508      @param pkgRdOnly ReadOnly
 509      @param pkgRePkg RePackage
 510      @param pkgSpec Reserved
 511      @param pkgOutDir Reserved
 512     **/
 513     public void genSpdHeader(String pkgName, String pkgGuid, String pkgVer, String pkgAbs, String pkgDes,
 514                              String pkgCpRight, String pkgLicense, String pkgCreateDate, String pkgUpdateDate,
 515                              String pkgURL, String pkgType, String pkgRdOnly, String pkgRePkg, String pkgSpec,
 516                              String pkgOutDir) {
 517         if (getSpdHdr() == null) {
 518             spdHdr = psaRoot.addNewSpdHeader();
 519         }
 520
 521         setSpdHdrPkgName(pkgName);
 522         setSpdHdrGuid(pkgGuid);
 523         setSpdHdrVer(pkgVer);
 524         setSpdHdrAbs(pkgAbs);
 525         setSpdHdrDes(pkgDes);
 526         setSpdHdrCpRit(pkgCpRight);
 527         setSpdHdrLicense(pkgLicense);
 528         setSpdHdrCreateDate(pkgCreateDate);
 529         setSpdHdrUpdateDate(pkgUpdateDate);
 530         setSpdHdrURL(pkgURL);
 531         setSpdHdrPkgType(pkgType);
 532         setSpdHdrRdOnly(pkgRdOnly);
 533         setSpdHdrRePkg(pkgRePkg);
 534         setSpdHdrSpec(pkgSpec);
 535         setSpdHdrOutDir(pkgOutDir);
 536     }
 537
 538     /**
 539      Generate library class declaration element using parameters passed in
 540
 541      @param libClassBaseName LibraryClass element value
 542      @param libClassUsage Reserved
 543      @param incHdrFileName IncludeHeader element value
 544      @param incHdrAttribGuid Reserved
 545      @param incHdrAttribArch Reserved
 546      @param incHdrAttribPath Reserved
 547      @param incHdrAttribClass Reserved
 548      @param incHdrAttribVer Reserved
 549      @param incHdrAttribOverrideID Reserved
 550      @param incHdrAttribModuleType Reserved
 551     **/
 552     public void genSpdLibClassDeclarations(String libClassBaseName, String libClassUsage, String incHdrFileName,
 553                                            String incHdrAttribGuid, String incHdrAttribArch, String incHdrAttribPath,
 554                                            String incHdrAttribClass, String incHdrAttribVer,
 555                                            String incHdrAttribOverrideID, String incHdrAttribModuleType) {
 556         if (getSpdLibClassDeclarations() == null) {
 557             spdLibClassDeclarations = psaRoot.addNewLibraryClassDeclarations();
 558         }
 559         //
 560         // add contents under LibraryClassDeclarations tag
 561         //
 562         setSpdLibClassDeclaration(libClassBaseName, libClassUsage, incHdrFileName, incHdrAttribGuid, incHdrAttribArch,
 563                                   incHdrAttribPath, incHdrAttribClass, incHdrAttribVer, incHdrAttribOverrideID,
 564                                   incHdrAttribModuleType, spdLibClassDeclarations);
 565     }
 566
 567     /**
 568      Set library class declaration contents under parent tag
 569
 570      @param clsName LibraryClass element value
 571      @param clsUsage Reserved
 572      @param hdrFile IncludeHeader element value
 573      @param hdrAttribGuid Reserved
 574      @param hdrAttribArch Reserved
 575      @param hdrAttribPath Reserved
 576      @param hdrAttribClass Reserved
 577      @param hdrAttribVer Reserved
 578      @param hdrAttribOverID Reserved
 579      @param hdrAttribModType Reserved
 580      @param parent The tag under which library class declaration goes to
 581     **/
 582     public void setSpdLibClassDeclaration(String clsName, String clsUsage, String hdrFile, String hdrAttribGuid,
 583                                           String hdrAttribArch, String hdrAttribPath, String hdrAttribClass,
 584                                           String hdrAttribVer, String hdrAttribOverID, String hdrAttribModType,
 585                                           XmlObject parent) {
 586
 587         LibraryClassDeclarationDocument.LibraryClassDeclaration lcd = ((LibraryClassDeclarationsDocument.LibraryClassDeclarations) parent)
 588                                                                                                                                           .addNewLibraryClassDeclaration();
 589
 590         setSpdLibraryClass(clsName, clsUsage, lcd);
 591
 592         setSpdIncludeHeader(null, hdrFile, hdrAttribGuid, hdrAttribArch, hdrAttribPath, hdrAttribClass, hdrAttribVer,
 593                             hdrAttribOverID, lcd);
 594     }
 595
 596     /**
 597      Set the contents of LibraryClass under parent element
 598
 599      @param clsName LibraryClass element value
 600      @param clsUsage Reserved
 601      @param parent The tag under which library class declaration goes to
 602     **/
 603     public void setSpdLibraryClass(String clsName, String clsUsage, XmlObject parent) {
 604         LibraryClassDeclarationDocument.LibraryClassDeclaration.LibraryClass lc = ((LibraryClassDeclarationDocument.LibraryClassDeclaration) parent).addNewLibraryClass();
 605         lc.setStringValue(clsName);
 606     }
 607
 608     /**
 609      Set contents of IncludeHeader under parent element
 610
 611      @param modType Reserved
 612      @param hdrFile IncludeHeader element value
 613      @param hdrAttribGuid Reserved
 614      @param hdrAttribArch Reserved
 615      @param hdrAttribPath Reserved
 616      @param hdrAttribClass Reserved
 617      @param hdrAttribVer Reserved
 618      @param hdrAttribOverID Reserved
 619      @param parent The tag under which library class declaration goes to
 620     **/
 621     public void setSpdIncludeHeader(String modType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
 622                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
 623                                     String hdrAttribOverID, XmlObject parent) {
 624         IncludeHeaderDocument.IncludeHeader ih = null;
 625         if (parent instanceof LibraryClassDeclarationDocument.LibraryClassDeclaration) {
 626             ih = ((LibraryClassDeclarationDocument.LibraryClassDeclaration) parent).addNewIncludeHeader();
 627         } else if (parent instanceof PackageHeadersDocument.PackageHeaders) {
 628             ih = ((PackageHeadersDocument.PackageHeaders) parent).addNewIncludeHeader();
 629         } else {
 630             return;
 631         }
 632
 633         ih.setStringValue(hdrFile);
 634         if (hdrAttribGuid != null) {
 635             ih.setGuid(hdrAttribGuid);
 636         }
 637         if (hdrAttribPath != null) {
 638             ih.setPath(hdrAttribPath);
 639         }
 640         if (hdrAttribClass != null) {
 641             ih.setClass1(hdrAttribClass);
 642         }
 643         if (hdrAttribVer != null) {
 644             ih.setVersion(hdrAttribVer);
 645         }
 646         if (hdrAttribOverID != null) {
 647             ih.setOverrideID(Integer.parseInt(hdrAttribOverID));
 648         }
 649         if (modType != null) {
 650             ih.setModuleType(ModuleTypeDef.Enum.forString(modType));
 651
 652         }
 653
 654     }
 655
 656     /**
 657      Reserved method
 658
 659      @param pkgDepPkgName
 660      @param pkgDepPkgAttribGuid
 661      @param pkgDepPkgAttribVer
 662      @param pkgDepPkgAttribType
 663      @param pkgDepPkgAttribUsage
 664      @param pkgDepPkgAttribInstallDate
 665      @param pkgDepPkgAttribUpdateDate
 666      @param pkgDepPkgAttribPath
 667     **/
 668     public void genSpdPackageDependencies(String pkgDepPkgName, String pkgDepPkgAttribGuid, String pkgDepPkgAttribVer,
 669                                           String pkgDepPkgAttribType, String pkgDepPkgAttribUsage,
 670                                           String pkgDepPkgAttribInstallDate, String pkgDepPkgAttribUpdateDate,
 671                                           String pkgDepPkgAttribPath) {
 672         if (spdPkgDeps == null) {
 673             spdPkgDeps = psaRoot.addNewPackageDependencies();
 674         }
 675
 676         setSpdPackageName(pkgDepPkgName, pkgDepPkgAttribGuid, pkgDepPkgAttribVer, pkgDepPkgAttribType,
 677                           pkgDepPkgAttribUsage, pkgDepPkgAttribInstallDate, pkgDepPkgAttribUpdateDate,
 678                           pkgDepPkgAttribPath, spdPkgDeps);
 679     }
 680
 681     /**
 682      Reserved method
 683
 684      @param pkgName
 685      @param pkgAttribGuid
 686      @param pkgAttribVer
 687      @param pkgAttribType
 688      @param pkgAttribUsage
 689      @param pkgAttribInstallDate
 690      @param pkgAttribUpdateDate
 691      @param pkgAttribPath
 692      @param parent
 693     **/
 694     public void setSpdPackageName(String pkgName, String pkgAttribGuid, String pkgAttribVer, String pkgAttribType,
 695                                   String pkgAttribUsage, String pkgAttribInstallDate, String pkgAttribUpdateDate,
 696                                   String pkgAttribPath, XmlObject parent) {
 697
 698         PackageNameDocument.PackageName pn = ((PackageDependenciesDocument.PackageDependencies) parent)
 699                                                                                                        .addNewPackageName();
 700         pn.setStringValue(pkgName);
 701         pn.setPackageType(PackageType.Enum.forString(pkgAttribType));
 702         pn.setUsage(PackageUsage.Enum.forString(pkgAttribUsage));
 703         pn.setUpdatedDate(pkgAttribUpdateDate);
 704     }
 705
 706     /**
 707      Generate MsaFile element.
 708
 709      @param msaFileName MsaFile element value
 710      @param archType Reserved
 711     **/
 712     public void genSpdMsaFiles(String msaFileName, String archType) {
 713         if (getSpdMsaFiles() == null) {
 714             spdMsaFiles = psaRoot.addNewMsaFiles();
 715         }
 716         setSpdMsaFile(msaFileName, spdMsaFiles);
 717
 718     }
 719
 720     /**
 721      Set MsaFile contents under parent element.
 722
 723      @param msaFileName MsaFile element value
 724      @param parent Element under which MsaFile goes to
 725     **/
 726     public void setSpdMsaFile(String msaFileName, XmlObject parent) {
 727
 728         ((MsaFilesDocument.MsaFiles) parent).addNewMsaFile().addNewFilename().setStringValue(msaFileName);
 729     }
 730
 731     /**
 732      Generate PackageHeader element using parameters passed in.
 733
 734      @param ModHdrModType ModuleType attribute of IncludeHeader element
 735      @param hdrFile IncludeHeader element value
 736      @param hdrAttribGuid Reserved
 737      @param hdrAttribArch Reserved
 738      @param hdrAttribPath Reserved
 739      @param hdrAttribClass Reserved
 740      @param hdrAttribVer Reserved
 741      @param hdrAttribOverID Reserved
 742     **/
 743     public void genSpdModuleHeaders(String ModHdrModType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
 744                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
 745                                     String hdrAttribOverID) {
 746         if (getSpdModHdrs() == null) {
 747             spdModHdrs = psaRoot.addNewPackageHeaders();
 748         }
 749
 750         //
 751         // add IncludeHeader under PackageHeaders element
 752         //
 753         setSpdIncludeHeader(ModHdrModType, hdrFile, hdrAttribGuid, hdrAttribArch, hdrAttribPath, hdrAttribClass,
 754                             hdrAttribVer, hdrAttribOverID, spdModHdrs);
 755     }
 756
 757     /**
 758      Generate GUID declaration element using parameters passed in.
 759
 760      @param guidDeclEntryName Name attribute of Entry element
 761      @param guidDeclCName CName element value
 762      @param guidDeclGuid Guid element value
 763      @param guidDeclFeatureFlag Reserved
 764     **/
 765     public void genSpdGuidDeclarations(String guidDeclEntryName, String guidDeclCName, String guidDeclGuid,
 766                                        String guidDeclFeatureFlag) {
 767         if (getSpdGuidDeclarations() == null) {
 768             spdGuidDeclarations = psaRoot.addNewGuidDeclarations();
 769         }
 770
 771         setSpdEntry(guidDeclEntryName, guidDeclCName, guidDeclGuid, guidDeclFeatureFlag, spdGuidDeclarations);
 772     }
 773
 774     /**
 775     Generate protocol declaration element using parameters passed in.
 776
 777     @param protocolDeclEntryName Name attribute of Entry element
 778     @param protocolDeclCName CName element value
 779     @param protocolDeclGuid Guid element value
 780     @param protocolDeclFeatureFlag Reserved
 781    **/
 782     public void genSpdProtocolDeclarations(String protocolDeclEntryName, String protocolDeclCName,
 783                                            String protocolDeclGuid, String protocolDeclFeatureFlag) {
 784         if (getSpdProtocolDeclarations() == null) {
 785             spdProtocolDeclarations = psaRoot.addNewProtocolDeclarations();
 786         }
 787
 788         setSpdEntry(protocolDeclEntryName, protocolDeclCName, protocolDeclGuid, protocolDeclFeatureFlag,
 789                     spdProtocolDeclarations);
 790     }
 791
 792     /**
 793     Generate PPI declaration element using parameters passed in.
 794
 795     @param ppiDeclEntryName Name attribute of Entry element
 796     @param ppiDeclCName CName element value
 797     @param ppiDeclGuid Guid element value
 798     @param ppiDeclFeatureFlag Reserved
 799    **/
 800     public void genSpdPpiDeclarations(String ppiDeclEntryName, String ppiDeclCName, String ppiDeclGuid,
 801                                       String ppiDeclFeatureFlag) {
 802         if (getSpdPpiDeclarations() == null) {
 803             spdPpiDeclarations = psaRoot.addNewPpiDeclarations();
 804         }
 805
 806         setSpdEntry(ppiDeclEntryName, ppiDeclCName, ppiDeclGuid, ppiDeclFeatureFlag, spdPpiDeclarations);
 807     }
 808
 809     /**
 810      Set Entry contents using parameters passed in
 811
 812      @param entryName Name attribute of Entry element
 813      @param cName CName element value
 814      @param guid Guid element value
 815      @param featureFlag Reserved
 816      @param parent The tag under which Entry element goes to
 817     **/
 818     public void setSpdEntry(String entryName, String cName, String guid, String featureFlag, XmlObject parent) {
 819
 820         if (parent instanceof GuidDeclarationsDocument.GuidDeclarations) {
 821             GuidDeclarationsDocument.GuidDeclarations.Entry e = ((GuidDeclarations) parent).addNewEntry();
 822             e.setName(entryName);
 823             e.setCName(cName);
 824             e.addNewGuid().setStringValue(guid);
 825
 826             return;
 827         }
 828         if (parent instanceof ProtocolDeclarationsDocument.ProtocolDeclarations) {
 829             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry pe = ((ProtocolDeclarationsDocument.ProtocolDeclarations) parent)
 830                                                                                                                                      .addNewEntry();
 831             pe.setName(entryName);
 832             pe.setCName(cName);
 833             pe.addNewGuid().setStringValue(guid);
 834
 835         }
 836         if (parent instanceof PpiDeclarationsDocument.PpiDeclarations) {
 837             PpiDeclarationsDocument.PpiDeclarations.Entry ppe = ((PpiDeclarationsDocument.PpiDeclarations) parent)
 838                                                                                                                   .addNewEntry();
 839             ppe.setName(entryName);
 840             ppe.setCName(cName);
 841             ppe.addNewGuid().setStringValue(guid);
 842
 843             return;
 844         }
 845
 846         return;
 847
 848     }
 849
 850     /**
 851      Generate Pcd definition using parameters passed in
 852
 853      @param pcdItemTypes ItemType attribute of PcdEntry element
 854      @param cName C_Name element value
 855      @param token Token element value
 856      @param dataType DatumType element value
 857      @param skuEnable Reserved
 858      @param sku Reserved
 859      @param maxSku Reserved
 860      @param hiiEnable Reserved
 861      @param varGuid Reserved
 862      @param varName Reserved
 863      @param defaultString DefaultString element value
 864     **/
 865     public void genSpdPcdDefinitions(String pcdItemTypes, String cName, String token, String dataType,
 866                                      String skuEnable, String sku, String maxSku, String hiiEnable, String varGuid,
 867                                      String varName, String defaultString) {
 868         if (getSpdPcdDefinitions() == null) {
 869             spdPcdDefinitions = psaRoot.addNewPcdDefinitions();
 870         }
 871
 872         setSpdPcdEntry(pcdItemTypes, cName, token, dataType, skuEnable, sku, maxSku, hiiEnable, varGuid, varName,
 873                        defaultString, spdPcdDefinitions);
 874     }
 875
 876     /**
 877      Set Pcd entry contents under parent tag
 878
 879      @param pcdItemTypes ItemType attribute of PcdEntry element
 880      @param cName C_Name element value
 881      @param token Token element value
 882      @param dataType DatumType element value
 883      @param skuEnable Reserved
 884      @param sku Reserved
 885      @param maxSku Reserved
 886      @param hiiEnable Reserved
 887      @param varGuid Reserved
 888      @param varName Reserved
 889      @param defaultString DefaultString element value
 890      @param parent Tag under which PcdEntry goes to
 891     **/
 892     public void setSpdPcdEntry(String pcdItemTypes, String cName, String token, String dataType, String skuEnable,
 893                                String sku, String maxSku, String hiiEnable, String varGuid, String varName,
 894                                String defaultString, XmlObject parent) {
 895
 896         PcdDefinitionsDocument.PcdDefinitions.PcdEntry pe = ((PcdDefinitionsDocument.PcdDefinitions) parent)
 897                                                                                                             .addNewPcdEntry();
 898         pe.setItemType(PcdItemTypes.Enum.forString(pcdItemTypes));
 899         pe.setCName(cName);
 900         pe.setToken(token);
 901         pe.setDatumType(PcdDataTypes.Enum.forString(dataType));
 902         pe.setDefaultValue(defaultString);
 903
 904     }
 905
 906     /**
 907      Get PpiDeclarations element
 908
 909      @return PpiDeclarationsDocument.PpiDeclarations
 910     **/
 911     public PpiDeclarationsDocument.PpiDeclarations getSpdPpiDeclarations() {
 912         if (spdPpiDeclarations == null) {
 913             spdPpiDeclarations = psaRoot.getPpiDeclarations();
 914         }
 915         return spdPpiDeclarations;
 916     }
 917
 918     /**
 919     Get ProtocolDeclarations element
 920
 921     @return ProtocolDeclarationsDocument.ProtocolDeclarations
 922     **/
 923     public ProtocolDeclarationsDocument.ProtocolDeclarations getSpdProtocolDeclarations() {
 924         if (spdProtocolDeclarations == null) {
 925             spdProtocolDeclarations = psaRoot.getProtocolDeclarations();
 926         }
 927         return spdProtocolDeclarations;
 928     }
 929
 930     /**
 931     Get GuidDeclarations element
 932
 933     @return GuidDeclarationsDocument.GuidDeclarations
 934     **/
 935     public GuidDeclarationsDocument.GuidDeclarations getSpdGuidDeclarations() {
 936         if (spdGuidDeclarations == null) {
 937             spdGuidDeclarations = psaRoot.getGuidDeclarations();
 938         }
 939         return spdGuidDeclarations;
 940     }
 941
 942     /**
 943      Get PcdDefinitions element
 944
 945      @return PcdDefinitionsDocument.PcdDefinitions
 946     **/
 947     public PcdDefinitionsDocument.PcdDefinitions getSpdPcdDefinitions() {
 948         if (spdPcdDefinitions == null) {
 949             spdPcdDefinitions = psaRoot.getPcdDefinitions();
 950         }
 951         return spdPcdDefinitions;
 952     }
 953
 954     /**
 955      Get PackageHeaders element
 956
 957      @return PackageHeadersDocument.PackageHeaders
 958     **/
 959     public PackageHeadersDocument.PackageHeaders getSpdModHdrs() {
 960         if (spdModHdrs == null) {
 961             spdModHdrs = psaRoot.getPackageHeaders();
 962         }
 963         return spdModHdrs;
 964     }
 965
 966     /**
 967      Get MsaFiles element
 968
 969      @return MsaFilesDocument.MsaFiles
 970     **/
 971     public MsaFilesDocument.MsaFiles getSpdMsaFiles() {
 972         if (spdMsaFiles == null) {
 973             spdMsaFiles = psaRoot.getMsaFiles();
 974         }
 975         return spdMsaFiles;
 976     }
 977
 978     /**
 979      Get LibraryClassDeclarations element
 980
 981      @return LibraryClassDeclarationsDocument.LibraryClassDeclarations
 982     **/
 983     public LibraryClassDeclarationsDocument.LibraryClassDeclarations getSpdLibClassDeclarations() {
 984         if (spdLibClassDeclarations == null) {
 985             spdLibClassDeclarations = psaRoot.getLibraryClassDeclarations();
 986         }
 987         return spdLibClassDeclarations;
 988     }
 989
 990     /**
 991      Get SpdHeader element
 992
 993      @return SpdHeaderDocument.SpdHeader
 994     **/
 995     public SpdHeaderDocument.SpdHeader getSpdHdr() {
 996         if (spdHdr == null) {
 997             spdHdr = psaRoot.getSpdHeader();
 998         }
 999         return spdHdr;
1000     }
1001
1002     /**
1003      Get Abstract element under tag SpdHeader
1004
1005      @return AbstractDocument.Abstract
1006     **/
1007     public AbstractDocument.Abstract getSpdHdrAbs() {
1008         if (spdHdrAbs == null) {
1009             spdHdrAbs = getSpdHdr().getAbstract();
1010         }
1011         return spdHdrAbs;
1012     }
1013
1014     /**
1015      Set value to Abstract element
1016
1017      @param abs The value set to Abstract element
1018     **/
1019     public void setSpdHdrAbs(String abs) {
1020
1021         if (getSpdHdrAbs() != null) {
1022             getSpdHdrAbs().setStringValue(abs);
1023         } else {
1024             spdHdrAbs = getSpdHdr().addNewAbstract();
1025             spdHdrAbs.setStringValue(abs);
1026         }
1027     }
1028
1029     /**
1030      Set value to Copyright element
1031
1032      @param cpRit The value set to Copyright element
1033     **/
1034     public void setSpdHdrCpRit(String cpRit) {
1035
1036         getSpdHdr().setCopyright(cpRit);
1037
1038     }
1039
1040     /**
1041      Set value to Created element
1042
1043      @param createDate The value set to Created element
1044     **/
1045     public void setSpdHdrCreateDate(String createDate) {
1046
1047         getSpdHdr().setCreated(createDate);
1048
1049     }
1050
1051     /**
1052      Set value to Description element
1053
1054      @param des The value set to Description element
1055     **/
1056     public void setSpdHdrDes(String des) {
1057         getSpdHdr().setDescription(des);
1058     }
1059
1060     /**
1061      Get Guid element under SpdHdr
1062
1063      @return GuidDocument.Guid
1064     **/
1065     public GuidDocument.Guid getSpdHdrGuid() {
1066         if (spdHdrGuid == null) {
1067             spdHdrGuid = getSpdHdr().getGuid();
1068         }
1069         return spdHdrGuid;
1070     }
1071
1072     /**
1073      Set value to Guid element
1074
1075      @param guid The value set to Guid element
1076     **/
1077     public void setSpdHdrGuid(String guid) {
1078         if (getSpdHdrGuid() != null) {
1079             getSpdHdrGuid().setStringValue(guid);
1080         } else {
1081             spdHdrGuid = getSpdHdr().addNewGuid();
1082             spdHdrGuid.setStringValue(guid);
1083         }
1084     }
1085
1086     /**
1087     Get Version element under SpdHdr
1088
1089     @return String
1090    **/
1091     public String getSpdHdrVer() {
1092         if (spdHdr != null)
1093             return spdHdr.getVersion() + "";
1094         else
1095             return null;
1096     }
1097
1098     /**
1099     Set value to Version element
1100
1101     @param ver The value set to Version element
1102    **/
1103     public void setSpdHdrVer(String ver) {
1104         if (spdHdr != null) {
1105             spdHdr.setVersion(new BigDecimal(ver.toCharArray()));
1106         }
1107
1108     }
1109
1110     /**
1111     Get License element under SpdHdr
1112
1113     @return LicenseDocument.License
1114    **/
1115     public LicenseDocument.License getSpdHdrLicense() {
1116         if (spdHdrLicense == null) {
1117             spdHdrLicense = getSpdHdr().getLicense();
1118         }
1119         return spdHdrLicense;
1120     }
1121
1122     /**
1123     Set value to License element
1124
1125     @param license The value set to License element
1126    **/
1127     public void setSpdHdrLicense(String license) {
1128         if (getSpdHdrLicense() != null) {
1129             getSpdHdrLicense().setStringValue(license);
1130         } else {
1131             spdHdrLicense = getSpdHdr().addNewLicense();
1132             spdHdrLicense.setStringValue(license);
1133         }
1134     }
1135
1136     /**
1137      Reserved method
1138
1139      @return
1140     **/
1141     public OutputDirectoryDocument.OutputDirectory getSpdHdrOutDir() {
1142         return spdHdrOutDir;
1143     }
1144
1145     /**
1146      Reserved method
1147
1148      @param outdir
1149     **/
1150     public void setSpdHdrOutDir(String outdir) {
1151         if (outdir == null) {
1152             return;
1153         }
1154         if (getSpdHdrOutDir() != null) {
1155             getSpdHdrOutDir().setStringValue(outdir);
1156         } else {
1157             spdHdrOutDir = getSpdHdr().addNewOutputDirectory();
1158             spdHdrOutDir.setStringValue(outdir);
1159         }
1160     }
1161
1162     /**
1163     Get PackageName element under SpdHdr
1164
1165     @return PackageNameDocument.PackageName
1166    **/
1167     public String getSpdHdrPkgName() {
1168         if (spdHdrPkgName == null) {
1169             spdHdrPkgName = getSpdHdr().getPackageName();
1170         }
1171         return spdHdrPkgName;
1172     }
1173
1174     /**
1175     Set value to PackageName element
1176
1177     @param pkgName The value set to PackageName element
1178    **/
1179     public void setSpdHdrPkgName(String pkgName) {
1180
1181         if (getSpdHdrPkgName() != null) {
1182             getSpdHdr().setPackageName(pkgName);
1183         } else {
1184             getSpdHdr().setPackageName(pkgName);
1185         }
1186     }
1187
1188     /**
1189     Reserved method
1190
1191     @return SpecificationDocument.Specification
1192    **/
1193     public SpecificationDocument.Specification getSpdHdrSpec() {
1194         return spdHdrSpec;
1195     }
1196
1197     /**
1198     Reserved method
1199
1200     @param spec
1201    **/
1202     public void setSpdHdrSpec(String spec) {
1203         if (spec == null) {
1204             return;
1205         }
1206         if (getSpdHdrSpec() != null) {
1207             getSpdHdrSpec().setStringValue(spec);
1208         } else {
1209             spdHdrSpec = getSpdHdr().addNewSpecification();
1210             spdHdrSpec.setStringValue(spec);
1211         }
1212     }
1213
1214     /**
1215     Set value to PackageType element
1216
1217     @param pkgType The value set to PackageType element
1218    **/
1219     public void setSpdHdrPkgType(String pkgType) {
1220         getSpdHdr().setPackageType(PackageType.Enum.forString(pkgType));
1221     }
1222
1223     /**
1224     Set value to ReadOnly element
1225
1226     @param rdOnly The value set to ReadOnly element
1227    **/
1228     public void setSpdHdrRdOnly(String rdOnly) {
1229
1230         getSpdHdr().setReadOnly(new Boolean(rdOnly));
1231     }
1232
1233     /**
1234     Set value to RePackage element
1235
1236     @param rePkg The value set to RePackage element
1237    **/
1238     public void setSpdHdrRePkg(String rePkg) {
1239
1240         getSpdHdr().setRePackage(new Boolean(rePkg));
1241     }
1242
1243     /**
1244     Set value to Updated element
1245
1246     @param updateDate The value set to Updated element
1247    **/
1248     public void setSpdHdrUpdateDate(String updateDate) {
1249         getSpdHdr().setUpdated(updateDate);
1250     }
1251
1252     /**
1253     Set value to URL element
1254
1255     @param url The value set to URL element
1256    **/
1257     public void setSpdHdrURL(String url) {
1258         getSpdHdr().setURL(url);
1259     }
1260
1261     /**
1262      Get xml file
1263
1264      @return File
1265     **/
1266     public File getFile() {
1267         return file;
1268     }
1269
1270     /**
1271      Set file
1272
1273      @param file File with xml format
1274     **/
1275     public void setFile(File file) {
1276         this.file = file;
1277     }
1278
1279 }