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
  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 PackageNameDocument.PackageName 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().getStringValue();
 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         LibraryClassDocument.LibraryClass lc = ((LibraryClassDeclarationDocument.LibraryClassDeclaration) parent)
 605                                                                                                                  .addNewLibraryClass();
 606         lc.setStringValue(clsName);
 607     }
 608
 609     /**
 610      Set contents of IncludeHeader under parent element
 611
 612      @param modType Reserved
 613      @param hdrFile IncludeHeader element value
 614      @param hdrAttribGuid Reserved
 615      @param hdrAttribArch Reserved
 616      @param hdrAttribPath Reserved
 617      @param hdrAttribClass Reserved
 618      @param hdrAttribVer Reserved
 619      @param hdrAttribOverID Reserved
 620      @param parent The tag under which library class declaration goes to
 621     **/
 622     public void setSpdIncludeHeader(String modType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
 623                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
 624                                     String hdrAttribOverID, XmlObject parent) {
 625         IncludeHeaderDocument.IncludeHeader ih = null;
 626         if (parent instanceof LibraryClassDeclarationDocument.LibraryClassDeclaration) {
 627             ih = ((LibraryClassDeclarationDocument.LibraryClassDeclaration) parent).addNewIncludeHeader();
 628         } else if (parent instanceof PackageHeadersDocument.PackageHeaders) {
 629             ih = ((PackageHeadersDocument.PackageHeaders) parent).addNewIncludeHeader();
 630         } else {
 631             return;
 632         }
 633
 634         ih.setStringValue(hdrFile);
 635         if (hdrAttribGuid != null) {
 636             ih.setGuid(hdrAttribGuid);
 637         }
 638         if (hdrAttribPath != null) {
 639             ih.setPath(hdrAttribPath);
 640         }
 641         if (hdrAttribClass != null) {
 642             ih.setClass1(hdrAttribClass);
 643         }
 644         if (hdrAttribVer != null) {
 645             ih.setVersion(hdrAttribVer);
 646         }
 647         if (hdrAttribOverID != null) {
 648             ih.setOverrideID(Integer.parseInt(hdrAttribOverID));
 649         }
 650         if (modType != null) {
 651             ih.setModuleType(ModuleTypeDef.Enum.forString(modType));
 652
 653         }
 654
 655     }
 656
 657     /**
 658      Reserved method
 659
 660      @param pkgDepPkgName
 661      @param pkgDepPkgAttribGuid
 662      @param pkgDepPkgAttribVer
 663      @param pkgDepPkgAttribType
 664      @param pkgDepPkgAttribUsage
 665      @param pkgDepPkgAttribInstallDate
 666      @param pkgDepPkgAttribUpdateDate
 667      @param pkgDepPkgAttribPath
 668     **/
 669     public void genSpdPackageDependencies(String pkgDepPkgName, String pkgDepPkgAttribGuid, String pkgDepPkgAttribVer,
 670                                           String pkgDepPkgAttribType, String pkgDepPkgAttribUsage,
 671                                           String pkgDepPkgAttribInstallDate, String pkgDepPkgAttribUpdateDate,
 672                                           String pkgDepPkgAttribPath) {
 673         if (spdPkgDeps == null) {
 674             spdPkgDeps = psaRoot.addNewPackageDependencies();
 675         }
 676
 677         setSpdPackageName(pkgDepPkgName, pkgDepPkgAttribGuid, pkgDepPkgAttribVer, pkgDepPkgAttribType,
 678                           pkgDepPkgAttribUsage, pkgDepPkgAttribInstallDate, pkgDepPkgAttribUpdateDate,
 679                           pkgDepPkgAttribPath, spdPkgDeps);
 680     }
 681
 682     /**
 683      Reserved method
 684
 685      @param pkgName
 686      @param pkgAttribGuid
 687      @param pkgAttribVer
 688      @param pkgAttribType
 689      @param pkgAttribUsage
 690      @param pkgAttribInstallDate
 691      @param pkgAttribUpdateDate
 692      @param pkgAttribPath
 693      @param parent
 694     **/
 695     public void setSpdPackageName(String pkgName, String pkgAttribGuid, String pkgAttribVer, String pkgAttribType,
 696                                   String pkgAttribUsage, String pkgAttribInstallDate, String pkgAttribUpdateDate,
 697                                   String pkgAttribPath, XmlObject parent) {
 698
 699         PackageNameDocument.PackageName pn = ((PackageDependenciesDocument.PackageDependencies) parent)
 700                                                                                                        .addNewPackageName();
 701         pn.setStringValue(pkgName);
 702         pn.setPackageType(PackageType.Enum.forString(pkgAttribType));
 703         pn.setUsage(PackageUsage.Enum.forString(pkgAttribUsage));
 704         pn.setUpdatedDate(pkgAttribUpdateDate);
 705     }
 706
 707     /**
 708      Generate MsaFile element.
 709
 710      @param msaFileName MsaFile element value
 711      @param archType Reserved
 712     **/
 713     public void genSpdMsaFiles(String msaFileName, String archType) {
 714         if (getSpdMsaFiles() == null) {
 715             spdMsaFiles = psaRoot.addNewMsaFiles();
 716         }
 717         setSpdMsaFile(msaFileName, spdMsaFiles);
 718
 719     }
 720
 721     /**
 722      Set MsaFile contents under parent element.
 723
 724      @param msaFileName MsaFile element value
 725      @param parent Element under which MsaFile goes to
 726     **/
 727     public void setSpdMsaFile(String msaFileName, XmlObject parent) {
 728
 729         ((MsaFilesDocument.MsaFiles) parent).addNewMsaFile().addNewFilename().setStringValue(msaFileName);
 730     }
 731
 732     /**
 733      Generate PackageHeader element using parameters passed in.
 734
 735      @param ModHdrModType ModuleType attribute of IncludeHeader element
 736      @param hdrFile IncludeHeader element value
 737      @param hdrAttribGuid Reserved
 738      @param hdrAttribArch Reserved
 739      @param hdrAttribPath Reserved
 740      @param hdrAttribClass Reserved
 741      @param hdrAttribVer Reserved
 742      @param hdrAttribOverID Reserved
 743     **/
 744     public void genSpdModuleHeaders(String ModHdrModType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
 745                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
 746                                     String hdrAttribOverID) {
 747         if (getSpdModHdrs() == null) {
 748             spdModHdrs = psaRoot.addNewPackageHeaders();
 749         }
 750
 751         //
 752         // add IncludeHeader under PackageHeaders element
 753         //
 754         setSpdIncludeHeader(ModHdrModType, hdrFile, hdrAttribGuid, hdrAttribArch, hdrAttribPath, hdrAttribClass,
 755                             hdrAttribVer, hdrAttribOverID, spdModHdrs);
 756     }
 757
 758     /**
 759      Generate GUID declaration element using parameters passed in.
 760
 761      @param guidDeclEntryName Name attribute of Entry element
 762      @param guidDeclCName CName element value
 763      @param guidDeclGuid Guid element value
 764      @param guidDeclFeatureFlag Reserved
 765     **/
 766     public void genSpdGuidDeclarations(String guidDeclEntryName, String guidDeclCName, String guidDeclGuid,
 767                                        String guidDeclFeatureFlag) {
 768         if (getSpdGuidDeclarations() == null) {
 769             spdGuidDeclarations = psaRoot.addNewGuidDeclarations();
 770         }
 771
 772         setSpdEntry(guidDeclEntryName, guidDeclCName, guidDeclGuid, guidDeclFeatureFlag, spdGuidDeclarations);
 773     }
 774
 775     /**
 776     Generate protocol declaration element using parameters passed in.
 777
 778     @param protocolDeclEntryName Name attribute of Entry element
 779     @param protocolDeclCName CName element value
 780     @param protocolDeclGuid Guid element value
 781     @param protocolDeclFeatureFlag Reserved
 782    **/
 783     public void genSpdProtocolDeclarations(String protocolDeclEntryName, String protocolDeclCName,
 784                                            String protocolDeclGuid, String protocolDeclFeatureFlag) {
 785         if (getSpdProtocolDeclarations() == null) {
 786             spdProtocolDeclarations = psaRoot.addNewProtocolDeclarations();
 787         }
 788
 789         setSpdEntry(protocolDeclEntryName, protocolDeclCName, protocolDeclGuid, protocolDeclFeatureFlag,
 790                     spdProtocolDeclarations);
 791     }
 792
 793     /**
 794     Generate PPI declaration element using parameters passed in.
 795
 796     @param ppiDeclEntryName Name attribute of Entry element
 797     @param ppiDeclCName CName element value
 798     @param ppiDeclGuid Guid element value
 799     @param ppiDeclFeatureFlag Reserved
 800    **/
 801     public void genSpdPpiDeclarations(String ppiDeclEntryName, String ppiDeclCName, String ppiDeclGuid,
 802                                       String ppiDeclFeatureFlag) {
 803         if (getSpdPpiDeclarations() == null) {
 804             spdPpiDeclarations = psaRoot.addNewPpiDeclarations();
 805         }
 806
 807         setSpdEntry(ppiDeclEntryName, ppiDeclCName, ppiDeclGuid, ppiDeclFeatureFlag, spdPpiDeclarations);
 808     }
 809
 810     /**
 811      Set Entry contents using parameters passed in
 812
 813      @param entryName Name attribute of Entry element
 814      @param cName CName element value
 815      @param guid Guid element value
 816      @param featureFlag Reserved
 817      @param parent The tag under which Entry element goes to
 818     **/
 819     public void setSpdEntry(String entryName, String cName, String guid, String featureFlag, XmlObject parent) {
 820
 821         if (parent instanceof GuidDeclarationsDocument.GuidDeclarations) {
 822             GuidDeclarationsDocument.GuidDeclarations.Entry e = ((GuidDeclarations) parent).addNewEntry();
 823             e.setName(entryName);
 824             e.setCName(cName);
 825             e.addNewGuid().setStringValue(guid);
 826             if (featureFlag != null) {
 827                 e.addNewFeatureFlag().setStringValue(featureFlag);
 828             }
 829             return;
 830         }
 831         if (parent instanceof ProtocolDeclarationsDocument.ProtocolDeclarations) {
 832             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry pe = ((ProtocolDeclarationsDocument.ProtocolDeclarations) parent)
 833                                                                                                                                      .addNewEntry();
 834             pe.setName(entryName);
 835             pe.setCName(cName);
 836             pe.addNewGuid().setStringValue(guid);
 837             if (featureFlag != null) {
 838                 pe.addNewFeatureFlag().setStringValue(featureFlag);
 839             }
 840             return;
 841         }
 842         if (parent instanceof PpiDeclarationsDocument.PpiDeclarations) {
 843             PpiDeclarationsDocument.PpiDeclarations.Entry ppe = ((PpiDeclarationsDocument.PpiDeclarations) parent)
 844                                                                                                                   .addNewEntry();
 845             ppe.setName(entryName);
 846             ppe.setCName(cName);
 847             ppe.addNewGuid().setStringValue(guid);
 848             if (featureFlag != null) {
 849                 ppe.addNewFeatureFlag().setStringValue(featureFlag);
 850             }
 851             return;
 852         }
 853
 854         return;
 855
 856     }
 857
 858     /**
 859      Generate Pcd definition using parameters passed in
 860
 861      @param pcdItemTypes ItemType attribute of PcdEntry element
 862      @param cName C_Name element value
 863      @param token Token element value
 864      @param dataType DatumType element value
 865      @param skuEnable Reserved
 866      @param sku Reserved
 867      @param maxSku Reserved
 868      @param hiiEnable Reserved
 869      @param varGuid Reserved
 870      @param varName Reserved
 871      @param defaultString DefaultString element value
 872     **/
 873     public void genSpdPcdDefinitions(String pcdItemTypes, String cName, String token, String dataType,
 874                                      String skuEnable, String sku, String maxSku, String hiiEnable, String varGuid,
 875                                      String varName, String defaultString) {
 876         if (getSpdPcdDefinitions() == null) {
 877             spdPcdDefinitions = psaRoot.addNewPcdDefinitions();
 878         }
 879
 880         setSpdPcdEntry(pcdItemTypes, cName, token, dataType, skuEnable, sku, maxSku, hiiEnable, varGuid, varName,
 881                        defaultString, spdPcdDefinitions);
 882     }
 883
 884     /**
 885      Set Pcd entry contents under parent tag
 886
 887      @param pcdItemTypes ItemType attribute of PcdEntry element
 888      @param cName C_Name element value
 889      @param token Token element value
 890      @param dataType DatumType element value
 891      @param skuEnable Reserved
 892      @param sku Reserved
 893      @param maxSku Reserved
 894      @param hiiEnable Reserved
 895      @param varGuid Reserved
 896      @param varName Reserved
 897      @param defaultString DefaultString element value
 898      @param parent Tag under which PcdEntry goes to
 899     **/
 900     public void setSpdPcdEntry(String pcdItemTypes, String cName, String token, String dataType, String skuEnable,
 901                                String sku, String maxSku, String hiiEnable, String varGuid, String varName,
 902                                String defaultString, XmlObject parent) {
 903
 904         PcdDefinitionsDocument.PcdDefinitions.PcdEntry pe = ((PcdDefinitionsDocument.PcdDefinitions) parent)
 905                                                                                                             .addNewPcdEntry();
 906         pe.setItemType(PcdItemTypes.Enum.forString(pcdItemTypes));
 907         pe.setCName(cName);
 908         pe.setToken(token);
 909         pe.setDatumType(PcdDataTypes.Enum.forString(dataType));
 910         pe.setDefaultValue(defaultString);
 911
 912     }
 913
 914     /**
 915      Get PpiDeclarations element
 916
 917      @return PpiDeclarationsDocument.PpiDeclarations
 918     **/
 919     public PpiDeclarationsDocument.PpiDeclarations getSpdPpiDeclarations() {
 920         if (spdPpiDeclarations == null) {
 921             spdPpiDeclarations = psaRoot.getPpiDeclarations();
 922         }
 923         return spdPpiDeclarations;
 924     }
 925
 926     /**
 927     Get ProtocolDeclarations element
 928
 929     @return ProtocolDeclarationsDocument.ProtocolDeclarations
 930     **/
 931     public ProtocolDeclarationsDocument.ProtocolDeclarations getSpdProtocolDeclarations() {
 932         if (spdProtocolDeclarations == null) {
 933             spdProtocolDeclarations = psaRoot.getProtocolDeclarations();
 934         }
 935         return spdProtocolDeclarations;
 936     }
 937
 938     /**
 939     Get GuidDeclarations element
 940
 941     @return GuidDeclarationsDocument.GuidDeclarations
 942     **/
 943     public GuidDeclarationsDocument.GuidDeclarations getSpdGuidDeclarations() {
 944         if (spdGuidDeclarations == null) {
 945             spdGuidDeclarations = psaRoot.getGuidDeclarations();
 946         }
 947         return spdGuidDeclarations;
 948     }
 949
 950     /**
 951      Get PcdDefinitions element
 952
 953      @return PcdDefinitionsDocument.PcdDefinitions
 954     **/
 955     public PcdDefinitionsDocument.PcdDefinitions getSpdPcdDefinitions() {
 956         if (spdPcdDefinitions == null) {
 957             spdPcdDefinitions = psaRoot.getPcdDefinitions();
 958         }
 959         return spdPcdDefinitions;
 960     }
 961
 962     /**
 963      Get PackageHeaders element
 964
 965      @return PackageHeadersDocument.PackageHeaders
 966     **/
 967     public PackageHeadersDocument.PackageHeaders getSpdModHdrs() {
 968         if (spdModHdrs == null) {
 969             spdModHdrs = psaRoot.getPackageHeaders();
 970         }
 971         return spdModHdrs;
 972     }
 973
 974     /**
 975      Get MsaFiles element
 976
 977      @return MsaFilesDocument.MsaFiles
 978     **/
 979     public MsaFilesDocument.MsaFiles getSpdMsaFiles() {
 980         if (spdMsaFiles == null) {
 981             spdMsaFiles = psaRoot.getMsaFiles();
 982         }
 983         return spdMsaFiles;
 984     }
 985
 986     /**
 987      Get LibraryClassDeclarations element
 988
 989      @return LibraryClassDeclarationsDocument.LibraryClassDeclarations
 990     **/
 991     public LibraryClassDeclarationsDocument.LibraryClassDeclarations getSpdLibClassDeclarations() {
 992         if (spdLibClassDeclarations == null) {
 993             spdLibClassDeclarations = psaRoot.getLibraryClassDeclarations();
 994         }
 995         return spdLibClassDeclarations;
 996     }
 997
 998     /**
 999      Get SpdHeader element
1000
1001      @return SpdHeaderDocument.SpdHeader
1002     **/
1003     public SpdHeaderDocument.SpdHeader getSpdHdr() {
1004         if (spdHdr == null) {
1005             spdHdr = psaRoot.getSpdHeader();
1006         }
1007         return spdHdr;
1008     }
1009
1010     /**
1011      Get Abstract element under tag SpdHeader
1012
1013      @return AbstractDocument.Abstract
1014     **/
1015     public AbstractDocument.Abstract getSpdHdrAbs() {
1016         if (spdHdrAbs == null) {
1017             spdHdrAbs = getSpdHdr().getAbstract();
1018         }
1019         return spdHdrAbs;
1020     }
1021
1022     /**
1023      Set value to Abstract element
1024
1025      @param abs The value set to Abstract element
1026     **/
1027     public void setSpdHdrAbs(String abs) {
1028
1029         if (getSpdHdrAbs() != null) {
1030             getSpdHdrAbs().setStringValue(abs);
1031         } else {
1032             spdHdrAbs = getSpdHdr().addNewAbstract();
1033             spdHdrAbs.setStringValue(abs);
1034         }
1035     }
1036
1037     /**
1038      Set value to Copyright element
1039
1040      @param cpRit The value set to Copyright element
1041     **/
1042     public void setSpdHdrCpRit(String cpRit) {
1043
1044         getSpdHdr().setCopyright(cpRit);
1045
1046     }
1047
1048     /**
1049      Set value to Created element
1050
1051      @param createDate The value set to Created element
1052     **/
1053     public void setSpdHdrCreateDate(String createDate) {
1054
1055         getSpdHdr().setCreated(createDate);
1056
1057     }
1058
1059     /**
1060      Set value to Description element
1061
1062      @param des The value set to Description element
1063     **/
1064     public void setSpdHdrDes(String des) {
1065         getSpdHdr().setDescription(des);
1066     }
1067
1068     /**
1069      Get Guid element under SpdHdr
1070
1071      @return GuidDocument.Guid
1072     **/
1073     public GuidDocument.Guid getSpdHdrGuid() {
1074         if (spdHdrGuid == null) {
1075             spdHdrGuid = getSpdHdr().getGuid();
1076         }
1077         return spdHdrGuid;
1078     }
1079
1080     /**
1081      Set value to Guid element
1082
1083      @param guid The value set to Guid element
1084     **/
1085     public void setSpdHdrGuid(String guid) {
1086         if (getSpdHdrGuid() != null) {
1087             getSpdHdrGuid().setStringValue(guid);
1088         } else {
1089             spdHdrGuid = getSpdHdr().addNewGuid();
1090             spdHdrGuid.setStringValue(guid);
1091         }
1092     }
1093
1094     /**
1095     Get Version element under SpdHdr
1096
1097     @return String
1098    **/
1099     public String getSpdHdrVer() {
1100         if (spdHdr != null)
1101             return spdHdr.getVersion();
1102         else
1103             return null;
1104     }
1105
1106     /**
1107     Set value to Version element
1108
1109     @param ver The value set to Version element
1110    **/
1111     public void setSpdHdrVer(String ver) {
1112         if (spdHdr != null) {
1113             spdHdr.setVersion(ver);
1114         }
1115
1116     }
1117
1118     /**
1119     Get License element under SpdHdr
1120
1121     @return LicenseDocument.License
1122    **/
1123     public LicenseDocument.License getSpdHdrLicense() {
1124         if (spdHdrLicense == null) {
1125             spdHdrLicense = getSpdHdr().getLicense();
1126         }
1127         return spdHdrLicense;
1128     }
1129
1130     /**
1131     Set value to License element
1132
1133     @param license The value set to License element
1134    **/
1135     public void setSpdHdrLicense(String license) {
1136         if (getSpdHdrLicense() != null) {
1137             getSpdHdrLicense().setStringValue(license);
1138         } else {
1139             spdHdrLicense = getSpdHdr().addNewLicense();
1140             spdHdrLicense.setStringValue(license);
1141         }
1142     }
1143
1144     /**
1145      Reserved method
1146
1147      @return
1148     **/
1149     public OutputDirectoryDocument.OutputDirectory getSpdHdrOutDir() {
1150         return spdHdrOutDir;
1151     }
1152
1153     /**
1154      Reserved method
1155
1156      @param outdir
1157     **/
1158     public void setSpdHdrOutDir(String outdir) {
1159         if (outdir == null) {
1160             return;
1161         }
1162         if (getSpdHdrOutDir() != null) {
1163             getSpdHdrOutDir().setStringValue(outdir);
1164         } else {
1165             spdHdrOutDir = getSpdHdr().addNewOutputDirectory();
1166             spdHdrOutDir.setStringValue(outdir);
1167         }
1168     }
1169
1170     /**
1171     Get PackageName element under SpdHdr
1172
1173     @return PackageNameDocument.PackageName
1174    **/
1175     public PackageNameDocument.PackageName getSpdHdrPkgName() {
1176         if (spdHdrPkgName == null) {
1177             spdHdrPkgName = getSpdHdr().getPackageName();
1178         }
1179         return spdHdrPkgName;
1180     }
1181
1182     /**
1183     Set value to PackageName element
1184
1185     @param pkgName The value set to PackageName element
1186    **/
1187     public void setSpdHdrPkgName(String pkgName) {
1188
1189         if (getSpdHdrPkgName() != null) {
1190             getSpdHdrPkgName().setStringValue(pkgName);
1191         } else {
1192             spdHdrPkgName = getSpdHdr().addNewPackageName();
1193             spdHdrPkgName.setStringValue(pkgName);
1194         }
1195     }
1196
1197     /**
1198     Reserved method
1199
1200     @return SpecificationDocument.Specification
1201    **/
1202     public SpecificationDocument.Specification getSpdHdrSpec() {
1203         return spdHdrSpec;
1204     }
1205
1206     /**
1207     Reserved method
1208
1209     @param spec
1210    **/
1211     public void setSpdHdrSpec(String spec) {
1212         if (spec == null) {
1213             return;
1214         }
1215         if (getSpdHdrSpec() != null) {
1216             getSpdHdrSpec().setStringValue(spec);
1217         } else {
1218             spdHdrSpec = getSpdHdr().addNewSpecification();
1219             spdHdrSpec.setStringValue(spec);
1220         }
1221     }
1222
1223     /**
1224     Set value to PackageType element
1225
1226     @param pkgType The value set to PackageType element
1227    **/
1228     public void setSpdHdrPkgType(String pkgType) {
1229         getSpdHdr().setPackageType(PackageType.Enum.forString(pkgType));
1230     }
1231
1232     /**
1233     Set value to ReadOnly element
1234
1235     @param rdOnly The value set to ReadOnly element
1236    **/
1237     public void setSpdHdrRdOnly(String rdOnly) {
1238
1239         getSpdHdr().setReadOnly(new Boolean(rdOnly));
1240     }
1241
1242     /**
1243     Set value to RePackage element
1244
1245     @param rePkg The value set to RePackage element
1246    **/
1247     public void setSpdHdrRePkg(String rePkg) {
1248
1249         getSpdHdr().setRePackage(new Boolean(rePkg));
1250     }
1251
1252     /**
1253     Set value to Updated element
1254
1255     @param updateDate The value set to Updated element
1256    **/
1257     public void setSpdHdrUpdateDate(String updateDate) {
1258         getSpdHdr().setUpdated(updateDate);
1259     }
1260
1261     /**
1262     Set value to URL element
1263
1264     @param url The value set to URL element
1265    **/
1266     public void setSpdHdrURL(String url) {
1267         getSpdHdr().setURL(url);
1268     }
1269
1270     /**
1271      Get xml file
1272
1273      @return File
1274     **/
1275     public File getFile() {
1276         return file;
1277     }
1278
1279     /**
1280      Set file
1281
1282      @param file File with xml format
1283     **/
1284     public void setFile(File file) {
1285         this.file = file;
1286     }
1287
1288 }