Coverage Report - org.apache.maven.plugins.assembly.model.io.xpp3.AssemblyXpp3Reader
 
Classes in this File Line Coverage Branch Coverage Complexity
AssemblyXpp3Reader
0%
0/1003
0%
0/276
16.84
 
 1   
 /*
 2   
  * $Id$
 3   
  */
 4   
 
 5   
 package org.apache.maven.plugins.assembly.model.io.xpp3;
 6   
 
 7   
   //---------------------------------/
 8   
  //- Imported classes and packages -/
 9   
 //---------------------------------/
 10   
 
 11   
 import java.io.ByteArrayInputStream;
 12   
 import java.io.IOException;
 13   
 import java.io.InputStreamReader;
 14   
 import java.io.Reader;
 15   
 import java.io.StringReader;
 16   
 import java.io.StringWriter;
 17   
 import java.text.DateFormat;
 18   
 import java.text.ParsePosition;
 19   
 import java.util.regex.Matcher;
 20   
 import java.util.regex.Pattern;
 21   
 import org.apache.maven.plugins.assembly.model.Assembly;
 22   
 import org.apache.maven.plugins.assembly.model.DependencySet;
 23   
 import org.apache.maven.plugins.assembly.model.FileItem;
 24   
 import org.apache.maven.plugins.assembly.model.FileSet;
 25   
 import org.apache.maven.plugins.assembly.model.GroupVersionAlignment;
 26   
 import org.apache.maven.plugins.assembly.model.ModuleBinaries;
 27   
 import org.apache.maven.plugins.assembly.model.ModuleSet;
 28   
 import org.apache.maven.plugins.assembly.model.ModuleSources;
 29   
 import org.apache.maven.plugins.assembly.model.Repository;
 30   
 import org.apache.maven.plugins.assembly.model.SetBase;
 31   
 import org.apache.maven.plugins.assembly.model.UnpackOptions;
 32   
 import org.codehaus.plexus.util.IOUtil;
 33   
 import org.codehaus.plexus.util.xml.pull.MXParser;
 34   
 import org.codehaus.plexus.util.xml.pull.XmlPullParser;
 35   
 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
 36   
 
 37   
 /**
 38   
  * Class AssemblyXpp3Reader.
 39   
  *
 40   
  * @version $Revision$ $Date$
 41   
  */
 42  0 
 public class AssemblyXpp3Reader {
 43   
 
 44   
 
 45   
       //--------------------------/
 46   
      //- Class/Member Variables -/
 47   
     //--------------------------/
 48   
 
 49   
     /**
 50   
      * If set the parser till be loaded with all single characters
 51   
      * from the XHTML specification.
 52   
      * The entities used:
 53   
      * <ul>
 54   
      * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
 55   
      * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
 56   
      * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
 57   
      * </ul>
 58   
      */
 59  0 
     private boolean addDefaultEntities = true;
 60   
 
 61   
 
 62   
       //-----------/
 63   
      //- Methods -/
 64   
     //-----------/
 65   
 
 66   
     /**
 67   
      * Method getAddDefaultEntities
 68   
      */
 69   
     public boolean getAddDefaultEntities()
 70   
     {
 71  0 
         return addDefaultEntities;
 72   
     } //-- boolean getAddDefaultEntities()
 73   
 
 74   
     /**
 75   
      * Method getBooleanValue
 76   
      *
 77   
      * @param s
 78   
      * @param parser
 79   
      * @param attribute
 80   
      */
 81   
     public boolean getBooleanValue(String s, String attribute, XmlPullParser parser)
 82   
         throws XmlPullParserException
 83   
     {
 84  0 
         if ( s != null )
 85   
         {
 86  0 
             return Boolean.valueOf( s ).booleanValue();
 87   
         }
 88  0 
         return false;
 89   
     } //-- boolean getBooleanValue(String, String, XmlPullParser)
 90   
 
 91   
     /**
 92   
      * Method getCharacterValue
 93   
      *
 94   
      * @param s
 95   
      * @param parser
 96   
      * @param attribute
 97   
      */
 98   
     public char getCharacterValue(String s, String attribute, XmlPullParser parser)
 99   
         throws XmlPullParserException
 100   
     {
 101  0 
         if ( s != null )
 102   
         {
 103  0 
             return s.charAt( 0 );
 104   
         }
 105  0 
         return 0;
 106   
     } //-- char getCharacterValue(String, String, XmlPullParser)
 107   
 
 108   
     /**
 109   
      * Method getDateValue
 110   
      *
 111   
      * @param s
 112   
      * @param parser
 113   
      * @param attribute
 114   
      */
 115   
     public java.util.Date getDateValue(String s, String attribute, XmlPullParser parser)
 116   
         throws XmlPullParserException
 117   
     {
 118  0 
         if ( s != null )
 119   
         {
 120  0 
             DateFormat dateParser = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL );
 121  0 
             return dateParser.parse( s, new ParsePosition( 0 ) );
 122   
         }
 123  0 
         return null;
 124   
     } //-- java.util.Date getDateValue(String, String, XmlPullParser)
 125   
 
 126   
     /**
 127   
      * Method getDoubleValue
 128   
      *
 129   
      * @param s
 130   
      * @param strict
 131   
      * @param parser
 132   
      * @param attribute
 133   
      */
 134   
     public double getDoubleValue(String s, String attribute, XmlPullParser parser, boolean strict)
 135   
         throws XmlPullParserException
 136   
     {
 137  0 
         if ( s != null )
 138   
         {
 139   
             try
 140   
             {
 141  0 
                 return Double.valueOf( s ).doubleValue();
 142   
             }
 143  0 
             catch ( NumberFormatException e )
 144   
             {
 145  0 
                 if ( strict )
 146   
                 {
 147  0 
                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
 148   
                 }
 149   
             }
 150   
         }
 151  0 
         return 0;
 152   
     } //-- double getDoubleValue(String, String, XmlPullParser, boolean)
 153   
 
 154   
     /**
 155   
      * Method getFloatValue
 156   
      *
 157   
      * @param s
 158   
      * @param strict
 159   
      * @param parser
 160   
      * @param attribute
 161   
      */
 162   
     public float getFloatValue(String s, String attribute, XmlPullParser parser, boolean strict)
 163   
         throws XmlPullParserException
 164   
     {
 165  0 
         if ( s != null )
 166   
         {
 167   
             try
 168   
             {
 169  0 
                 return Float.valueOf( s ).floatValue();
 170   
             }
 171  0 
             catch ( NumberFormatException e )
 172   
             {
 173  0 
                 if ( strict )
 174   
                 {
 175  0 
                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
 176   
                 }
 177   
             }
 178   
         }
 179  0 
         return 0;
 180   
     } //-- float getFloatValue(String, String, XmlPullParser, boolean)
 181   
 
 182   
     /**
 183   
      * Method getIntegerValue
 184   
      *
 185   
      * @param s
 186   
      * @param strict
 187   
      * @param parser
 188   
      * @param attribute
 189   
      */
 190   
     public int getIntegerValue(String s, String attribute, XmlPullParser parser, boolean strict)
 191   
         throws XmlPullParserException
 192   
     {
 193  0 
         if ( s != null )
 194   
         {
 195   
             try
 196   
             {
 197  0 
                 return Integer.valueOf( s ).intValue();
 198   
             }
 199  0 
             catch ( NumberFormatException e )
 200   
             {
 201  0 
                 if ( strict )
 202   
                 {
 203  0 
                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, null );
 204   
                 }
 205   
             }
 206   
         }
 207  0 
         return 0;
 208   
     } //-- int getIntegerValue(String, String, XmlPullParser, boolean)
 209   
 
 210   
     /**
 211   
      * Method getLongValue
 212   
      *
 213   
      * @param s
 214   
      * @param strict
 215   
      * @param parser
 216   
      * @param attribute
 217   
      */
 218   
     public long getLongValue(String s, String attribute, XmlPullParser parser, boolean strict)
 219   
         throws XmlPullParserException
 220   
     {
 221  0 
         if ( s != null )
 222   
         {
 223   
             try
 224   
             {
 225  0 
                 return Long.valueOf( s ).longValue();
 226   
             }
 227  0 
             catch ( NumberFormatException e )
 228   
             {
 229  0 
                 if ( strict )
 230   
                 {
 231  0 
                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, null );
 232   
                 }
 233   
             }
 234   
         }
 235  0 
         return 0;
 236   
     } //-- long getLongValue(String, String, XmlPullParser, boolean)
 237   
 
 238   
     /**
 239   
      * Method getRequiredAttributeValue
 240   
      *
 241   
      * @param s
 242   
      * @param strict
 243   
      * @param parser
 244   
      * @param attribute
 245   
      */
 246   
     public String getRequiredAttributeValue(String s, String attribute, XmlPullParser parser, boolean strict)
 247   
         throws XmlPullParserException
 248   
     {
 249  0 
         if ( s == null )
 250   
         {
 251  0 
             if ( strict )
 252   
             {
 253  0 
                 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
 254   
             }
 255   
         }
 256  0 
         return s;
 257   
     } //-- String getRequiredAttributeValue(String, String, XmlPullParser, boolean)
 258   
 
 259   
     /**
 260   
      * Method getShortValue
 261   
      *
 262   
      * @param s
 263   
      * @param strict
 264   
      * @param parser
 265   
      * @param attribute
 266   
      */
 267   
     public short getShortValue(String s, String attribute, XmlPullParser parser, boolean strict)
 268   
         throws XmlPullParserException
 269   
     {
 270  0 
         if ( s != null )
 271   
         {
 272   
             try
 273   
             {
 274  0 
                 return Short.valueOf( s ).shortValue();
 275   
             }
 276  0 
             catch ( NumberFormatException e )
 277   
             {
 278  0 
                 if ( strict )
 279   
                 {
 280  0 
                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, null );
 281   
                 }
 282   
             }
 283   
         }
 284  0 
         return 0;
 285   
     } //-- short getShortValue(String, String, XmlPullParser, boolean)
 286   
 
 287   
     /**
 288   
      * Method getTrimmedValue
 289   
      *
 290   
      * @param s
 291   
      */
 292   
     public String getTrimmedValue(String s)
 293   
     {
 294  0 
         if ( s != null )
 295   
         {
 296  0 
             s = s.trim();
 297   
         }
 298  0 
         return s;
 299   
     } //-- String getTrimmedValue(String)
 300   
 
 301   
     /**
 302   
      * Method parseAssembly
 303   
      *
 304   
      * @param tagName
 305   
      * @param encoding
 306   
      * @param strict
 307   
      * @param parser
 308   
      */
 309   
     private Assembly parseAssembly(String tagName, XmlPullParser parser, boolean strict, String encoding)
 310   
         throws IOException, XmlPullParserException
 311   
     {
 312  0 
         Assembly assembly = new Assembly();
 313  0 
         assembly.setModelEncoding( encoding );
 314  0 
         java.util.Set parsed = new java.util.HashSet();
 315  0 
         int eventType = parser.getEventType();
 316  0 
         boolean foundRoot = false;
 317  0 
         while ( eventType != XmlPullParser.END_DOCUMENT )
 318   
         {
 319  0 
             if ( eventType == XmlPullParser.START_TAG )
 320   
             {
 321  0 
                 if ( parser.getName().equals( tagName ) )
 322   
                 {
 323  0 
                     foundRoot = true;
 324   
                 }
 325  0 
                 else if ( parser.getName().equals( "id" )  )
 326   
                 {
 327  0 
                     if ( parsed.contains( "id" ) )
 328   
                     {
 329  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 330   
                     }
 331  0 
                     parsed.add( "id" );
 332  0 
                     assembly.setId( getTrimmedValue( parser.nextText()) );
 333   
                 }
 334  0 
                 else if ( parser.getName().equals( "formats" )  )
 335   
                 {
 336  0 
                     if ( parsed.contains( "formats" ) )
 337   
                     {
 338  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 339   
                     }
 340  0 
                     parsed.add( "formats" );
 341  0 
                     java.util.List formats = new java.util.ArrayList();
 342  0 
                     assembly.setFormats( formats );
 343  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 344   
                     {
 345  0 
                         if ( parser.getName().equals( "format" ) )
 346   
                         {
 347  0 
                             formats.add( getTrimmedValue( parser.nextText()) );
 348   
                         }
 349   
                         else
 350   
                         {
 351  0 
                             parser.nextText();
 352   
                         }
 353   
                     }
 354  0 
                 }
 355  0 
                 else if ( parser.getName().equals( "includeBaseDirectory" )  )
 356   
                 {
 357  0 
                     if ( parsed.contains( "includeBaseDirectory" ) )
 358   
                     {
 359  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 360   
                     }
 361  0 
                     parsed.add( "includeBaseDirectory" );
 362  0 
                     assembly.setIncludeBaseDirectory( getBooleanValue( getTrimmedValue( parser.nextText()), "includeBaseDirectory", parser ) );
 363   
                 }
 364  0 
                 else if ( parser.getName().equals( "baseDirectory" )  )
 365   
                 {
 366  0 
                     if ( parsed.contains( "baseDirectory" ) )
 367   
                     {
 368  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 369   
                     }
 370  0 
                     parsed.add( "baseDirectory" );
 371  0 
                     assembly.setBaseDirectory( getTrimmedValue( parser.nextText()) );
 372   
                 }
 373  0 
                 else if ( parser.getName().equals( "includeSiteDirectory" )  )
 374   
                 {
 375  0 
                     if ( parsed.contains( "includeSiteDirectory" ) )
 376   
                     {
 377  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 378   
                     }
 379  0 
                     parsed.add( "includeSiteDirectory" );
 380  0 
                     assembly.setIncludeSiteDirectory( getBooleanValue( getTrimmedValue( parser.nextText()), "includeSiteDirectory", parser ) );
 381   
                 }
 382  0 
                 else if ( parser.getName().equals( "moduleSets" )  )
 383   
                 {
 384  0 
                     if ( parsed.contains( "moduleSets" ) )
 385   
                     {
 386  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 387   
                     }
 388  0 
                     parsed.add( "moduleSets" );
 389  0 
                     java.util.List moduleSets = new java.util.ArrayList();
 390  0 
                     assembly.setModuleSets( moduleSets );
 391  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 392   
                     {
 393  0 
                         if ( parser.getName().equals( "moduleSet" ) )
 394   
                         {
 395  0 
                             moduleSets.add( parseModuleSet( "moduleSet", parser, strict, encoding ) );
 396   
                         }
 397   
                         else
 398   
                         {
 399  0 
                             parser.nextText();
 400   
                         }
 401   
                     }
 402  0 
                 }
 403  0 
                 else if ( parser.getName().equals( "fileSets" )  )
 404   
                 {
 405  0 
                     if ( parsed.contains( "fileSets" ) )
 406   
                     {
 407  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 408   
                     }
 409  0 
                     parsed.add( "fileSets" );
 410  0 
                     java.util.List fileSets = new java.util.ArrayList();
 411  0 
                     assembly.setFileSets( fileSets );
 412  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 413   
                     {
 414  0 
                         if ( parser.getName().equals( "fileSet" ) )
 415   
                         {
 416  0 
                             fileSets.add( parseFileSet( "fileSet", parser, strict, encoding ) );
 417   
                         }
 418   
                         else
 419   
                         {
 420  0 
                             parser.nextText();
 421   
                         }
 422   
                     }
 423  0 
                 }
 424  0 
                 else if ( parser.getName().equals( "files" )  )
 425   
                 {
 426  0 
                     if ( parsed.contains( "files" ) )
 427   
                     {
 428  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 429   
                     }
 430  0 
                     parsed.add( "files" );
 431  0 
                     java.util.List files = new java.util.ArrayList();
 432  0 
                     assembly.setFiles( files );
 433  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 434   
                     {
 435  0 
                         if ( parser.getName().equals( "file" ) )
 436   
                         {
 437  0 
                             files.add( parseFileItem( "file", parser, strict, encoding ) );
 438   
                         }
 439   
                         else
 440   
                         {
 441  0 
                             parser.nextText();
 442   
                         }
 443   
                     }
 444  0 
                 }
 445  0 
                 else if ( parser.getName().equals( "dependencySets" )  )
 446   
                 {
 447  0 
                     if ( parsed.contains( "dependencySets" ) )
 448   
                     {
 449  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 450   
                     }
 451  0 
                     parsed.add( "dependencySets" );
 452  0 
                     java.util.List dependencySets = new java.util.ArrayList();
 453  0 
                     assembly.setDependencySets( dependencySets );
 454  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 455   
                     {
 456  0 
                         if ( parser.getName().equals( "dependencySet" ) )
 457   
                         {
 458  0 
                             dependencySets.add( parseDependencySet( "dependencySet", parser, strict, encoding ) );
 459   
                         }
 460   
                         else
 461   
                         {
 462  0 
                             parser.nextText();
 463   
                         }
 464   
                     }
 465  0 
                 }
 466  0 
                 else if ( parser.getName().equals( "repositories" )  )
 467   
                 {
 468  0 
                     if ( parsed.contains( "repositories" ) )
 469   
                     {
 470  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 471   
                     }
 472  0 
                     parsed.add( "repositories" );
 473  0 
                     java.util.List repositories = new java.util.ArrayList();
 474  0 
                     assembly.setRepositories( repositories );
 475  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 476   
                     {
 477  0 
                         if ( parser.getName().equals( "repository" ) )
 478   
                         {
 479  0 
                             repositories.add( parseRepository( "repository", parser, strict, encoding ) );
 480   
                         }
 481   
                         else
 482   
                         {
 483  0 
                             parser.nextText();
 484   
                         }
 485   
                     }
 486  0 
                 }
 487  0 
                 else if ( parser.getName().equals( "componentDescriptors" )  )
 488   
                 {
 489  0 
                     if ( parsed.contains( "componentDescriptors" ) )
 490   
                     {
 491  0 
                         throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 492   
                     }
 493  0 
                     parsed.add( "componentDescriptors" );
 494  0 
                     java.util.List componentDescriptors = new java.util.ArrayList();
 495  0 
                     assembly.setComponentDescriptors( componentDescriptors );
 496  0 
                     while ( parser.nextTag() == XmlPullParser.START_TAG )
 497   
                     {
 498  0 
                         if ( parser.getName().equals( "componentDescriptor" ) )
 499   
                         {
 500  0 
                             componentDescriptors.add( getTrimmedValue( parser.nextText()) );
 501   
                         }
 502   
                         else
 503   
                         {
 504  0 
                             parser.nextText();
 505   
                         }
 506   
                     }
 507  0 
                 }
 508   
                 else
 509   
                 {
 510  0 
                     if ( foundRoot )
 511   
                     {
 512  0 
                         if ( strict )
 513   
                         {
 514  0 
                             throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 515   
                         }
 516   
                     }
 517   
                 }
 518   
             }
 519  0 
             eventType = parser.next();
 520   
         }
 521  0 
         return assembly;
 522   
     } //-- Assembly parseAssembly(String, XmlPullParser, boolean, String)
 523   
 
 524   
     /**
 525   
      * Method parseDependencySet
 526   
      *
 527   
      * @param tagName
 528   
      * @param encoding
 529   
      * @param strict
 530   
      * @param parser
 531   
      */
 532   
     private DependencySet parseDependencySet(String tagName, XmlPullParser parser, boolean strict, String encoding)
 533   
         throws IOException, XmlPullParserException
 534   
     {
 535  0 
         DependencySet dependencySet = new DependencySet();
 536  0 
         dependencySet.setModelEncoding( encoding );
 537  0 
         java.util.Set parsed = new java.util.HashSet();
 538  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 539   
         {
 540  0 
             if ( parser.getName().equals( "outputFileNameMapping" )  )
 541   
             {
 542  0 
                 if ( parsed.contains( "outputFileNameMapping" ) )
 543   
                 {
 544  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 545   
                 }
 546  0 
                 parsed.add( "outputFileNameMapping" );
 547  0 
                 dependencySet.setOutputFileNameMapping( getTrimmedValue( parser.nextText()) );
 548   
             }
 549  0 
             else if ( parser.getName().equals( "unpack" )  )
 550   
             {
 551  0 
                 if ( parsed.contains( "unpack" ) )
 552   
                 {
 553  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 554   
                 }
 555  0 
                 parsed.add( "unpack" );
 556  0 
                 dependencySet.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText()), "unpack", parser ) );
 557   
             }
 558  0 
             else if ( parser.getName().equals( "unpackOptions" )  )
 559   
             {
 560  0 
                 if ( parsed.contains( "unpackOptions" ) )
 561   
                 {
 562  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 563   
                 }
 564  0 
                 parsed.add( "unpackOptions" );
 565  0 
                 dependencySet.setUnpackOptions( parseUnpackOptions( "unpackOptions", parser, strict, encoding ) );
 566   
             }
 567  0 
             else if ( parser.getName().equals( "scope" )  )
 568   
             {
 569  0 
                 if ( parsed.contains( "scope" ) )
 570   
                 {
 571  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 572   
                 }
 573  0 
                 parsed.add( "scope" );
 574  0 
                 dependencySet.setScope( getTrimmedValue( parser.nextText()) );
 575   
             }
 576  0 
             else if ( parser.getName().equals( "useStrictFiltering" )  )
 577   
             {
 578  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 579   
                 {
 580  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 581   
                 }
 582  0 
                 parsed.add( "useStrictFiltering" );
 583  0 
                 dependencySet.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 584   
             }
 585  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 586   
             {
 587  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 588   
                 {
 589  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 590   
                 }
 591  0 
                 parsed.add( "useDefaultExcludes" );
 592  0 
                 dependencySet.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 593   
             }
 594  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 595   
             {
 596  0 
                 if ( parsed.contains( "outputDirectory" ) )
 597   
                 {
 598  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 599   
                 }
 600  0 
                 parsed.add( "outputDirectory" );
 601  0 
                 dependencySet.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 602   
             }
 603  0 
             else if ( parser.getName().equals( "includes" )  )
 604   
             {
 605  0 
                 if ( parsed.contains( "includes" ) )
 606   
                 {
 607  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 608   
                 }
 609  0 
                 parsed.add( "includes" );
 610  0 
                 java.util.List includes = new java.util.ArrayList();
 611  0 
                 dependencySet.setIncludes( includes );
 612  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 613   
                 {
 614  0 
                     if ( parser.getName().equals( "include" ) )
 615   
                     {
 616  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 617   
                     }
 618   
                     else
 619   
                     {
 620  0 
                         parser.nextText();
 621   
                     }
 622   
                 }
 623  0 
             }
 624  0 
             else if ( parser.getName().equals( "excludes" )  )
 625   
             {
 626  0 
                 if ( parsed.contains( "excludes" ) )
 627   
                 {
 628  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 629   
                 }
 630  0 
                 parsed.add( "excludes" );
 631  0 
                 java.util.List excludes = new java.util.ArrayList();
 632  0 
                 dependencySet.setExcludes( excludes );
 633  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 634   
                 {
 635  0 
                     if ( parser.getName().equals( "exclude" ) )
 636   
                     {
 637  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 638   
                     }
 639   
                     else
 640   
                     {
 641  0 
                         parser.nextText();
 642   
                     }
 643   
                 }
 644  0 
             }
 645  0 
             else if ( parser.getName().equals( "fileMode" )  )
 646   
             {
 647  0 
                 if ( parsed.contains( "fileMode" ) )
 648   
                 {
 649  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 650   
                 }
 651  0 
                 parsed.add( "fileMode" );
 652  0 
                 dependencySet.setFileMode( getTrimmedValue( parser.nextText()) );
 653   
             }
 654  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 655   
             {
 656  0 
                 if ( parsed.contains( "directoryMode" ) )
 657   
                 {
 658  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 659   
                 }
 660  0 
                 parsed.add( "directoryMode" );
 661  0 
                 dependencySet.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 662   
             }
 663   
             else
 664   
             {
 665  0 
                 if ( strict )
 666   
                 {
 667  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 668   
                 }
 669   
             }
 670   
         }
 671  0 
         return dependencySet;
 672   
     } //-- DependencySet parseDependencySet(String, XmlPullParser, boolean, String)
 673   
 
 674   
     /**
 675   
      * Method parseFileItem
 676   
      *
 677   
      * @param tagName
 678   
      * @param encoding
 679   
      * @param strict
 680   
      * @param parser
 681   
      */
 682   
     private FileItem parseFileItem(String tagName, XmlPullParser parser, boolean strict, String encoding)
 683   
         throws IOException, XmlPullParserException
 684   
     {
 685  0 
         FileItem fileItem = new FileItem();
 686  0 
         fileItem.setModelEncoding( encoding );
 687  0 
         java.util.Set parsed = new java.util.HashSet();
 688  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 689   
         {
 690  0 
             if ( parser.getName().equals( "source" )  )
 691   
             {
 692  0 
                 if ( parsed.contains( "source" ) )
 693   
                 {
 694  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 695   
                 }
 696  0 
                 parsed.add( "source" );
 697  0 
                 fileItem.setSource( getTrimmedValue( parser.nextText()) );
 698   
             }
 699  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 700   
             {
 701  0 
                 if ( parsed.contains( "outputDirectory" ) )
 702   
                 {
 703  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 704   
                 }
 705  0 
                 parsed.add( "outputDirectory" );
 706  0 
                 fileItem.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 707   
             }
 708  0 
             else if ( parser.getName().equals( "destName" )  )
 709   
             {
 710  0 
                 if ( parsed.contains( "destName" ) )
 711   
                 {
 712  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 713   
                 }
 714  0 
                 parsed.add( "destName" );
 715  0 
                 fileItem.setDestName( getTrimmedValue( parser.nextText()) );
 716   
             }
 717  0 
             else if ( parser.getName().equals( "fileMode" )  )
 718   
             {
 719  0 
                 if ( parsed.contains( "fileMode" ) )
 720   
                 {
 721  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 722   
                 }
 723  0 
                 parsed.add( "fileMode" );
 724  0 
                 fileItem.setFileMode( getTrimmedValue( parser.nextText()) );
 725   
             }
 726  0 
             else if ( parser.getName().equals( "lineEnding" )  )
 727   
             {
 728  0 
                 if ( parsed.contains( "lineEnding" ) )
 729   
                 {
 730  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 731   
                 }
 732  0 
                 parsed.add( "lineEnding" );
 733  0 
                 fileItem.setLineEnding( getTrimmedValue( parser.nextText()) );
 734   
             }
 735  0 
             else if ( parser.getName().equals( "filtered" )  )
 736   
             {
 737  0 
                 if ( parsed.contains( "filtered" ) )
 738   
                 {
 739  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 740   
                 }
 741  0 
                 parsed.add( "filtered" );
 742  0 
                 fileItem.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText()), "filtered", parser ) );
 743   
             }
 744   
             else
 745   
             {
 746  0 
                 if ( strict )
 747   
                 {
 748  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 749   
                 }
 750   
             }
 751   
         }
 752  0 
         return fileItem;
 753   
     } //-- FileItem parseFileItem(String, XmlPullParser, boolean, String)
 754   
 
 755   
     /**
 756   
      * Method parseFileSet
 757   
      *
 758   
      * @param tagName
 759   
      * @param encoding
 760   
      * @param strict
 761   
      * @param parser
 762   
      */
 763   
     private FileSet parseFileSet(String tagName, XmlPullParser parser, boolean strict, String encoding)
 764   
         throws IOException, XmlPullParserException
 765   
     {
 766  0 
         FileSet fileSet = new FileSet();
 767  0 
         fileSet.setModelEncoding( encoding );
 768  0 
         java.util.Set parsed = new java.util.HashSet();
 769  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 770   
         {
 771  0 
             if ( parser.getName().equals( "directory" )  )
 772   
             {
 773  0 
                 if ( parsed.contains( "directory" ) )
 774   
                 {
 775  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 776   
                 }
 777  0 
                 parsed.add( "directory" );
 778  0 
                 fileSet.setDirectory( getTrimmedValue( parser.nextText()) );
 779   
             }
 780  0 
             else if ( parser.getName().equals( "lineEnding" )  )
 781   
             {
 782  0 
                 if ( parsed.contains( "lineEnding" ) )
 783   
                 {
 784  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 785   
                 }
 786  0 
                 parsed.add( "lineEnding" );
 787  0 
                 fileSet.setLineEnding( getTrimmedValue( parser.nextText()) );
 788   
             }
 789  0 
             else if ( parser.getName().equals( "filtered" )  )
 790   
             {
 791  0 
                 if ( parsed.contains( "filtered" ) )
 792   
                 {
 793  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 794   
                 }
 795  0 
                 parsed.add( "filtered" );
 796  0 
                 fileSet.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText()), "filtered", parser ) );
 797   
             }
 798  0 
             else if ( parser.getName().equals( "useStrictFiltering" )  )
 799   
             {
 800  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 801   
                 {
 802  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 803   
                 }
 804  0 
                 parsed.add( "useStrictFiltering" );
 805  0 
                 fileSet.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 806   
             }
 807  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 808   
             {
 809  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 810   
                 {
 811  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 812   
                 }
 813  0 
                 parsed.add( "useDefaultExcludes" );
 814  0 
                 fileSet.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 815   
             }
 816  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 817   
             {
 818  0 
                 if ( parsed.contains( "outputDirectory" ) )
 819   
                 {
 820  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 821   
                 }
 822  0 
                 parsed.add( "outputDirectory" );
 823  0 
                 fileSet.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 824   
             }
 825  0 
             else if ( parser.getName().equals( "includes" )  )
 826   
             {
 827  0 
                 if ( parsed.contains( "includes" ) )
 828   
                 {
 829  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 830   
                 }
 831  0 
                 parsed.add( "includes" );
 832  0 
                 java.util.List includes = new java.util.ArrayList();
 833  0 
                 fileSet.setIncludes( includes );
 834  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 835   
                 {
 836  0 
                     if ( parser.getName().equals( "include" ) )
 837   
                     {
 838  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 839   
                     }
 840   
                     else
 841   
                     {
 842  0 
                         parser.nextText();
 843   
                     }
 844   
                 }
 845  0 
             }
 846  0 
             else if ( parser.getName().equals( "excludes" )  )
 847   
             {
 848  0 
                 if ( parsed.contains( "excludes" ) )
 849   
                 {
 850  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 851   
                 }
 852  0 
                 parsed.add( "excludes" );
 853  0 
                 java.util.List excludes = new java.util.ArrayList();
 854  0 
                 fileSet.setExcludes( excludes );
 855  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 856   
                 {
 857  0 
                     if ( parser.getName().equals( "exclude" ) )
 858   
                     {
 859  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 860   
                     }
 861   
                     else
 862   
                     {
 863  0 
                         parser.nextText();
 864   
                     }
 865   
                 }
 866  0 
             }
 867  0 
             else if ( parser.getName().equals( "fileMode" )  )
 868   
             {
 869  0 
                 if ( parsed.contains( "fileMode" ) )
 870   
                 {
 871  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 872   
                 }
 873  0 
                 parsed.add( "fileMode" );
 874  0 
                 fileSet.setFileMode( getTrimmedValue( parser.nextText()) );
 875   
             }
 876  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 877   
             {
 878  0 
                 if ( parsed.contains( "directoryMode" ) )
 879   
                 {
 880  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 881   
                 }
 882  0 
                 parsed.add( "directoryMode" );
 883  0 
                 fileSet.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 884   
             }
 885   
             else
 886   
             {
 887  0 
                 if ( strict )
 888   
                 {
 889  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 890   
                 }
 891   
             }
 892   
         }
 893  0 
         return fileSet;
 894   
     } //-- FileSet parseFileSet(String, XmlPullParser, boolean, String)
 895   
 
 896   
     /**
 897   
      * Method parseGroupVersionAlignment
 898   
      *
 899   
      * @param tagName
 900   
      * @param encoding
 901   
      * @param strict
 902   
      * @param parser
 903   
      */
 904   
     private GroupVersionAlignment parseGroupVersionAlignment(String tagName, XmlPullParser parser, boolean strict, String encoding)
 905   
         throws IOException, XmlPullParserException
 906   
     {
 907  0 
         GroupVersionAlignment groupVersionAlignment = new GroupVersionAlignment();
 908  0 
         groupVersionAlignment.setModelEncoding( encoding );
 909  0 
         java.util.Set parsed = new java.util.HashSet();
 910  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 911   
         {
 912  0 
             if ( parser.getName().equals( "id" )  )
 913   
             {
 914  0 
                 if ( parsed.contains( "id" ) )
 915   
                 {
 916  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 917   
                 }
 918  0 
                 parsed.add( "id" );
 919  0 
                 groupVersionAlignment.setId( getTrimmedValue( parser.nextText()) );
 920   
             }
 921  0 
             else if ( parser.getName().equals( "version" )  )
 922   
             {
 923  0 
                 if ( parsed.contains( "version" ) )
 924   
                 {
 925  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 926   
                 }
 927  0 
                 parsed.add( "version" );
 928  0 
                 groupVersionAlignment.setVersion( getTrimmedValue( parser.nextText()) );
 929   
             }
 930  0 
             else if ( parser.getName().equals( "excludes" )  )
 931   
             {
 932  0 
                 if ( parsed.contains( "excludes" ) )
 933   
                 {
 934  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 935   
                 }
 936  0 
                 parsed.add( "excludes" );
 937  0 
                 java.util.List excludes = new java.util.ArrayList();
 938  0 
                 groupVersionAlignment.setExcludes( excludes );
 939  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 940   
                 {
 941  0 
                     if ( parser.getName().equals( "exclude" ) )
 942   
                     {
 943  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 944   
                     }
 945   
                     else
 946   
                     {
 947  0 
                         parser.nextText();
 948   
                     }
 949   
                 }
 950  0 
             }
 951   
             else
 952   
             {
 953  0 
                 if ( strict )
 954   
                 {
 955  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 956   
                 }
 957   
             }
 958   
         }
 959  0 
         return groupVersionAlignment;
 960   
     } //-- GroupVersionAlignment parseGroupVersionAlignment(String, XmlPullParser, boolean, String)
 961   
 
 962   
     /**
 963   
      * Method parseModuleBinaries
 964   
      *
 965   
      * @param tagName
 966   
      * @param encoding
 967   
      * @param strict
 968   
      * @param parser
 969   
      */
 970   
     private ModuleBinaries parseModuleBinaries(String tagName, XmlPullParser parser, boolean strict, String encoding)
 971   
         throws IOException, XmlPullParserException
 972   
     {
 973  0 
         ModuleBinaries moduleBinaries = new ModuleBinaries();
 974  0 
         moduleBinaries.setModelEncoding( encoding );
 975  0 
         java.util.Set parsed = new java.util.HashSet();
 976  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 977   
         {
 978  0 
             if ( parser.getName().equals( "attachmentClassifier" )  )
 979   
             {
 980  0 
                 if ( parsed.contains( "attachmentClassifier" ) )
 981   
                 {
 982  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 983   
                 }
 984  0 
                 parsed.add( "attachmentClassifier" );
 985  0 
                 moduleBinaries.setAttachmentClassifier( getTrimmedValue( parser.nextText()) );
 986   
             }
 987  0 
             else if ( parser.getName().equals( "includeDependencies" )  )
 988   
             {
 989  0 
                 if ( parsed.contains( "includeDependencies" ) )
 990   
                 {
 991  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 992   
                 }
 993  0 
                 parsed.add( "includeDependencies" );
 994  0 
                 moduleBinaries.setIncludeDependencies( getBooleanValue( getTrimmedValue( parser.nextText()), "includeDependencies", parser ) );
 995   
             }
 996  0 
             else if ( parser.getName().equals( "dependencySets" )  )
 997   
             {
 998  0 
                 if ( parsed.contains( "dependencySets" ) )
 999   
                 {
 1000  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1001   
                 }
 1002  0 
                 parsed.add( "dependencySets" );
 1003  0 
                 java.util.List dependencySets = new java.util.ArrayList();
 1004  0 
                 moduleBinaries.setDependencySets( dependencySets );
 1005  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1006   
                 {
 1007  0 
                     if ( parser.getName().equals( "dependencySet" ) )
 1008   
                     {
 1009  0 
                         dependencySets.add( parseDependencySet( "dependencySet", parser, strict, encoding ) );
 1010   
                     }
 1011   
                     else
 1012   
                     {
 1013  0 
                         parser.nextText();
 1014   
                     }
 1015   
                 }
 1016  0 
             }
 1017  0 
             else if ( parser.getName().equals( "unpack" )  )
 1018   
             {
 1019  0 
                 if ( parsed.contains( "unpack" ) )
 1020   
                 {
 1021  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1022   
                 }
 1023  0 
                 parsed.add( "unpack" );
 1024  0 
                 moduleBinaries.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText()), "unpack", parser ) );
 1025   
             }
 1026  0 
             else if ( parser.getName().equals( "unpackOptions" )  )
 1027   
             {
 1028  0 
                 if ( parsed.contains( "unpackOptions" ) )
 1029   
                 {
 1030  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1031   
                 }
 1032  0 
                 parsed.add( "unpackOptions" );
 1033  0 
                 moduleBinaries.setUnpackOptions( parseUnpackOptions( "unpackOptions", parser, strict, encoding ) );
 1034   
             }
 1035  0 
             else if ( parser.getName().equals( "outputFileNameMapping" )  )
 1036   
             {
 1037  0 
                 if ( parsed.contains( "outputFileNameMapping" ) )
 1038   
                 {
 1039  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1040   
                 }
 1041  0 
                 parsed.add( "outputFileNameMapping" );
 1042  0 
                 moduleBinaries.setOutputFileNameMapping( getTrimmedValue( parser.nextText()) );
 1043   
             }
 1044  0 
             else if ( parser.getName().equals( "useStrictFiltering" )  )
 1045   
             {
 1046  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 1047   
                 {
 1048  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1049   
                 }
 1050  0 
                 parsed.add( "useStrictFiltering" );
 1051  0 
                 moduleBinaries.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 1052   
             }
 1053  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 1054   
             {
 1055  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 1056   
                 {
 1057  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1058   
                 }
 1059  0 
                 parsed.add( "useDefaultExcludes" );
 1060  0 
                 moduleBinaries.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 1061   
             }
 1062  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 1063   
             {
 1064  0 
                 if ( parsed.contains( "outputDirectory" ) )
 1065   
                 {
 1066  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1067   
                 }
 1068  0 
                 parsed.add( "outputDirectory" );
 1069  0 
                 moduleBinaries.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 1070   
             }
 1071  0 
             else if ( parser.getName().equals( "includes" )  )
 1072   
             {
 1073  0 
                 if ( parsed.contains( "includes" ) )
 1074   
                 {
 1075  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1076   
                 }
 1077  0 
                 parsed.add( "includes" );
 1078  0 
                 java.util.List includes = new java.util.ArrayList();
 1079  0 
                 moduleBinaries.setIncludes( includes );
 1080  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1081   
                 {
 1082  0 
                     if ( parser.getName().equals( "include" ) )
 1083   
                     {
 1084  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1085   
                     }
 1086   
                     else
 1087   
                     {
 1088  0 
                         parser.nextText();
 1089   
                     }
 1090   
                 }
 1091  0 
             }
 1092  0 
             else if ( parser.getName().equals( "excludes" )  )
 1093   
             {
 1094  0 
                 if ( parsed.contains( "excludes" ) )
 1095   
                 {
 1096  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1097   
                 }
 1098  0 
                 parsed.add( "excludes" );
 1099  0 
                 java.util.List excludes = new java.util.ArrayList();
 1100  0 
                 moduleBinaries.setExcludes( excludes );
 1101  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1102   
                 {
 1103  0 
                     if ( parser.getName().equals( "exclude" ) )
 1104   
                     {
 1105  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1106   
                     }
 1107   
                     else
 1108   
                     {
 1109  0 
                         parser.nextText();
 1110   
                     }
 1111   
                 }
 1112  0 
             }
 1113  0 
             else if ( parser.getName().equals( "fileMode" )  )
 1114   
             {
 1115  0 
                 if ( parsed.contains( "fileMode" ) )
 1116   
                 {
 1117  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1118   
                 }
 1119  0 
                 parsed.add( "fileMode" );
 1120  0 
                 moduleBinaries.setFileMode( getTrimmedValue( parser.nextText()) );
 1121   
             }
 1122  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 1123   
             {
 1124  0 
                 if ( parsed.contains( "directoryMode" ) )
 1125   
                 {
 1126  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1127   
                 }
 1128  0 
                 parsed.add( "directoryMode" );
 1129  0 
                 moduleBinaries.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 1130   
             }
 1131   
             else
 1132   
             {
 1133  0 
                 if ( strict )
 1134   
                 {
 1135  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1136   
                 }
 1137   
             }
 1138   
         }
 1139  0 
         return moduleBinaries;
 1140   
     } //-- ModuleBinaries parseModuleBinaries(String, XmlPullParser, boolean, String)
 1141   
 
 1142   
     /**
 1143   
      * Method parseModuleSet
 1144   
      *
 1145   
      * @param tagName
 1146   
      * @param encoding
 1147   
      * @param strict
 1148   
      * @param parser
 1149   
      */
 1150   
     private ModuleSet parseModuleSet(String tagName, XmlPullParser parser, boolean strict, String encoding)
 1151   
         throws IOException, XmlPullParserException
 1152   
     {
 1153  0 
         ModuleSet moduleSet = new ModuleSet();
 1154  0 
         moduleSet.setModelEncoding( encoding );
 1155  0 
         java.util.Set parsed = new java.util.HashSet();
 1156  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 1157   
         {
 1158  0 
             if ( parser.getName().equals( "includeSubModules" )  )
 1159   
             {
 1160  0 
                 if ( parsed.contains( "includeSubModules" ) )
 1161   
                 {
 1162  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1163   
                 }
 1164  0 
                 parsed.add( "includeSubModules" );
 1165  0 
                 moduleSet.setIncludeSubModules( getBooleanValue( getTrimmedValue( parser.nextText()), "includeSubModules", parser ) );
 1166   
             }
 1167  0 
             else if ( parser.getName().equals( "includes" )  )
 1168   
             {
 1169  0 
                 if ( parsed.contains( "includes" ) )
 1170   
                 {
 1171  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1172   
                 }
 1173  0 
                 parsed.add( "includes" );
 1174  0 
                 java.util.List includes = new java.util.ArrayList();
 1175  0 
                 moduleSet.setIncludes( includes );
 1176  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1177   
                 {
 1178  0 
                     if ( parser.getName().equals( "include" ) )
 1179   
                     {
 1180  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1181   
                     }
 1182   
                     else
 1183   
                     {
 1184  0 
                         parser.nextText();
 1185   
                     }
 1186   
                 }
 1187  0 
             }
 1188  0 
             else if ( parser.getName().equals( "excludes" )  )
 1189   
             {
 1190  0 
                 if ( parsed.contains( "excludes" ) )
 1191   
                 {
 1192  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1193   
                 }
 1194  0 
                 parsed.add( "excludes" );
 1195  0 
                 java.util.List excludes = new java.util.ArrayList();
 1196  0 
                 moduleSet.setExcludes( excludes );
 1197  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1198   
                 {
 1199  0 
                     if ( parser.getName().equals( "exclude" ) )
 1200   
                     {
 1201  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1202   
                     }
 1203   
                     else
 1204   
                     {
 1205  0 
                         parser.nextText();
 1206   
                     }
 1207   
                 }
 1208  0 
             }
 1209  0 
             else if ( parser.getName().equals( "sources" )  )
 1210   
             {
 1211  0 
                 if ( parsed.contains( "sources" ) )
 1212   
                 {
 1213  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1214   
                 }
 1215  0 
                 parsed.add( "sources" );
 1216  0 
                 moduleSet.setSources( parseModuleSources( "sources", parser, strict, encoding ) );
 1217   
             }
 1218  0 
             else if ( parser.getName().equals( "binaries" )  )
 1219   
             {
 1220  0 
                 if ( parsed.contains( "binaries" ) )
 1221   
                 {
 1222  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1223   
                 }
 1224  0 
                 parsed.add( "binaries" );
 1225  0 
                 moduleSet.setBinaries( parseModuleBinaries( "binaries", parser, strict, encoding ) );
 1226   
             }
 1227   
             else
 1228   
             {
 1229  0 
                 if ( strict )
 1230   
                 {
 1231  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1232   
                 }
 1233   
             }
 1234   
         }
 1235  0 
         return moduleSet;
 1236   
     } //-- ModuleSet parseModuleSet(String, XmlPullParser, boolean, String)
 1237   
 
 1238   
     /**
 1239   
      * Method parseModuleSources
 1240   
      *
 1241   
      * @param tagName
 1242   
      * @param encoding
 1243   
      * @param strict
 1244   
      * @param parser
 1245   
      */
 1246   
     private ModuleSources parseModuleSources(String tagName, XmlPullParser parser, boolean strict, String encoding)
 1247   
         throws IOException, XmlPullParserException
 1248   
     {
 1249  0 
         ModuleSources moduleSources = new ModuleSources();
 1250  0 
         moduleSources.setModelEncoding( encoding );
 1251  0 
         java.util.Set parsed = new java.util.HashSet();
 1252  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 1253   
         {
 1254  0 
             if ( parser.getName().equals( "fileSets" )  )
 1255   
             {
 1256  0 
                 if ( parsed.contains( "fileSets" ) )
 1257   
                 {
 1258  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1259   
                 }
 1260  0 
                 parsed.add( "fileSets" );
 1261  0 
                 java.util.List fileSets = new java.util.ArrayList();
 1262  0 
                 moduleSources.setFileSets( fileSets );
 1263  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1264   
                 {
 1265  0 
                     if ( parser.getName().equals( "fileSet" ) )
 1266   
                     {
 1267  0 
                         fileSets.add( parseFileSet( "fileSet", parser, strict, encoding ) );
 1268   
                     }
 1269   
                     else
 1270   
                     {
 1271  0 
                         parser.nextText();
 1272   
                     }
 1273   
                 }
 1274  0 
             }
 1275  0 
             else if ( parser.getName().equals( "includeModuleDirectory" )  )
 1276   
             {
 1277  0 
                 if ( parsed.contains( "includeModuleDirectory" ) )
 1278   
                 {
 1279  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1280   
                 }
 1281  0 
                 parsed.add( "includeModuleDirectory" );
 1282  0 
                 moduleSources.setIncludeModuleDirectory( getBooleanValue( getTrimmedValue( parser.nextText()), "includeModuleDirectory", parser ) );
 1283   
             }
 1284  0 
             else if ( parser.getName().equals( "excludeSubModuleDirectories" )  )
 1285   
             {
 1286  0 
                 if ( parsed.contains( "excludeSubModuleDirectories" ) )
 1287   
                 {
 1288  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1289   
                 }
 1290  0 
                 parsed.add( "excludeSubModuleDirectories" );
 1291  0 
                 moduleSources.setExcludeSubModuleDirectories( getBooleanValue( getTrimmedValue( parser.nextText()), "excludeSubModuleDirectories", parser ) );
 1292   
             }
 1293  0 
             else if ( parser.getName().equals( "outputDirectoryMapping" )  )
 1294   
             {
 1295  0 
                 if ( parsed.contains( "outputDirectoryMapping" ) )
 1296   
                 {
 1297  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1298   
                 }
 1299  0 
                 parsed.add( "outputDirectoryMapping" );
 1300  0 
                 moduleSources.setOutputDirectoryMapping( getTrimmedValue( parser.nextText()) );
 1301   
             }
 1302  0 
             else if ( parser.getName().equals( "useStrictFiltering" )  )
 1303   
             {
 1304  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 1305   
                 {
 1306  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1307   
                 }
 1308  0 
                 parsed.add( "useStrictFiltering" );
 1309  0 
                 moduleSources.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 1310   
             }
 1311  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 1312   
             {
 1313  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 1314   
                 {
 1315  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1316   
                 }
 1317  0 
                 parsed.add( "useDefaultExcludes" );
 1318  0 
                 moduleSources.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 1319   
             }
 1320  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 1321   
             {
 1322  0 
                 if ( parsed.contains( "outputDirectory" ) )
 1323   
                 {
 1324  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1325   
                 }
 1326  0 
                 parsed.add( "outputDirectory" );
 1327  0 
                 moduleSources.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 1328   
             }
 1329  0 
             else if ( parser.getName().equals( "includes" )  )
 1330   
             {
 1331  0 
                 if ( parsed.contains( "includes" ) )
 1332   
                 {
 1333  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1334   
                 }
 1335  0 
                 parsed.add( "includes" );
 1336  0 
                 java.util.List includes = new java.util.ArrayList();
 1337  0 
                 moduleSources.setIncludes( includes );
 1338  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1339   
                 {
 1340  0 
                     if ( parser.getName().equals( "include" ) )
 1341   
                     {
 1342  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1343   
                     }
 1344   
                     else
 1345   
                     {
 1346  0 
                         parser.nextText();
 1347   
                     }
 1348   
                 }
 1349  0 
             }
 1350  0 
             else if ( parser.getName().equals( "excludes" )  )
 1351   
             {
 1352  0 
                 if ( parsed.contains( "excludes" ) )
 1353   
                 {
 1354  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1355   
                 }
 1356  0 
                 parsed.add( "excludes" );
 1357  0 
                 java.util.List excludes = new java.util.ArrayList();
 1358  0 
                 moduleSources.setExcludes( excludes );
 1359  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1360   
                 {
 1361  0 
                     if ( parser.getName().equals( "exclude" ) )
 1362   
                     {
 1363  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1364   
                     }
 1365   
                     else
 1366   
                     {
 1367  0 
                         parser.nextText();
 1368   
                     }
 1369   
                 }
 1370  0 
             }
 1371  0 
             else if ( parser.getName().equals( "fileMode" )  )
 1372   
             {
 1373  0 
                 if ( parsed.contains( "fileMode" ) )
 1374   
                 {
 1375  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1376   
                 }
 1377  0 
                 parsed.add( "fileMode" );
 1378  0 
                 moduleSources.setFileMode( getTrimmedValue( parser.nextText()) );
 1379   
             }
 1380  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 1381   
             {
 1382  0 
                 if ( parsed.contains( "directoryMode" ) )
 1383   
                 {
 1384  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1385   
                 }
 1386  0 
                 parsed.add( "directoryMode" );
 1387  0 
                 moduleSources.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 1388   
             }
 1389   
             else
 1390   
             {
 1391  0 
                 if ( strict )
 1392   
                 {
 1393  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1394   
                 }
 1395   
             }
 1396   
         }
 1397  0 
         return moduleSources;
 1398   
     } //-- ModuleSources parseModuleSources(String, XmlPullParser, boolean, String)
 1399   
 
 1400   
     /**
 1401   
      * Method parseRepository
 1402   
      *
 1403   
      * @param tagName
 1404   
      * @param encoding
 1405   
      * @param strict
 1406   
      * @param parser
 1407   
      */
 1408   
     private Repository parseRepository(String tagName, XmlPullParser parser, boolean strict, String encoding)
 1409   
         throws IOException, XmlPullParserException
 1410   
     {
 1411  0 
         Repository repository = new Repository();
 1412  0 
         repository.setModelEncoding( encoding );
 1413  0 
         java.util.Set parsed = new java.util.HashSet();
 1414  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 1415   
         {
 1416  0 
             if ( parser.getName().equals( "includeMetadata" )  )
 1417   
             {
 1418  0 
                 if ( parsed.contains( "includeMetadata" ) )
 1419   
                 {
 1420  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1421   
                 }
 1422  0 
                 parsed.add( "includeMetadata" );
 1423  0 
                 repository.setIncludeMetadata( getBooleanValue( getTrimmedValue( parser.nextText()), "includeMetadata", parser ) );
 1424   
             }
 1425  0 
             else if ( parser.getName().equals( "groupVersionAlignments" )  )
 1426   
             {
 1427  0 
                 if ( parsed.contains( "groupVersionAlignments" ) )
 1428   
                 {
 1429  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1430   
                 }
 1431  0 
                 parsed.add( "groupVersionAlignments" );
 1432  0 
                 java.util.List groupVersionAlignments = new java.util.ArrayList();
 1433  0 
                 repository.setGroupVersionAlignments( groupVersionAlignments );
 1434  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1435   
                 {
 1436  0 
                     if ( parser.getName().equals( "groupVersionAlignment" ) )
 1437   
                     {
 1438  0 
                         groupVersionAlignments.add( parseGroupVersionAlignment( "groupVersionAlignment", parser, strict, encoding ) );
 1439   
                     }
 1440   
                     else
 1441   
                     {
 1442  0 
                         parser.nextText();
 1443   
                     }
 1444   
                 }
 1445  0 
             }
 1446  0 
             else if ( parser.getName().equals( "scope" )  )
 1447   
             {
 1448  0 
                 if ( parsed.contains( "scope" ) )
 1449   
                 {
 1450  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1451   
                 }
 1452  0 
                 parsed.add( "scope" );
 1453  0 
                 repository.setScope( getTrimmedValue( parser.nextText()) );
 1454   
             }
 1455  0 
             else if ( parser.getName().equals( "useStrictFiltering" )  )
 1456   
             {
 1457  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 1458   
                 {
 1459  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1460   
                 }
 1461  0 
                 parsed.add( "useStrictFiltering" );
 1462  0 
                 repository.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 1463   
             }
 1464  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 1465   
             {
 1466  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 1467   
                 {
 1468  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1469   
                 }
 1470  0 
                 parsed.add( "useDefaultExcludes" );
 1471  0 
                 repository.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 1472   
             }
 1473  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 1474   
             {
 1475  0 
                 if ( parsed.contains( "outputDirectory" ) )
 1476   
                 {
 1477  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1478   
                 }
 1479  0 
                 parsed.add( "outputDirectory" );
 1480  0 
                 repository.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 1481   
             }
 1482  0 
             else if ( parser.getName().equals( "includes" )  )
 1483   
             {
 1484  0 
                 if ( parsed.contains( "includes" ) )
 1485   
                 {
 1486  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1487   
                 }
 1488  0 
                 parsed.add( "includes" );
 1489  0 
                 java.util.List includes = new java.util.ArrayList();
 1490  0 
                 repository.setIncludes( includes );
 1491  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1492   
                 {
 1493  0 
                     if ( parser.getName().equals( "include" ) )
 1494   
                     {
 1495  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1496   
                     }
 1497   
                     else
 1498   
                     {
 1499  0 
                         parser.nextText();
 1500   
                     }
 1501   
                 }
 1502  0 
             }
 1503  0 
             else if ( parser.getName().equals( "excludes" )  )
 1504   
             {
 1505  0 
                 if ( parsed.contains( "excludes" ) )
 1506   
                 {
 1507  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1508   
                 }
 1509  0 
                 parsed.add( "excludes" );
 1510  0 
                 java.util.List excludes = new java.util.ArrayList();
 1511  0 
                 repository.setExcludes( excludes );
 1512  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1513   
                 {
 1514  0 
                     if ( parser.getName().equals( "exclude" ) )
 1515   
                     {
 1516  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1517   
                     }
 1518   
                     else
 1519   
                     {
 1520  0 
                         parser.nextText();
 1521   
                     }
 1522   
                 }
 1523  0 
             }
 1524  0 
             else if ( parser.getName().equals( "fileMode" )  )
 1525   
             {
 1526  0 
                 if ( parsed.contains( "fileMode" ) )
 1527   
                 {
 1528  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1529   
                 }
 1530  0 
                 parsed.add( "fileMode" );
 1531  0 
                 repository.setFileMode( getTrimmedValue( parser.nextText()) );
 1532   
             }
 1533  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 1534   
             {
 1535  0 
                 if ( parsed.contains( "directoryMode" ) )
 1536   
                 {
 1537  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1538   
                 }
 1539  0 
                 parsed.add( "directoryMode" );
 1540  0 
                 repository.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 1541   
             }
 1542   
             else
 1543   
             {
 1544  0 
                 if ( strict )
 1545   
                 {
 1546  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1547   
                 }
 1548   
             }
 1549   
         }
 1550  0 
         return repository;
 1551   
     } //-- Repository parseRepository(String, XmlPullParser, boolean, String)
 1552   
 
 1553   
     /**
 1554   
      * Method parseSetBase
 1555   
      *
 1556   
      * @param tagName
 1557   
      * @param encoding
 1558   
      * @param strict
 1559   
      * @param parser
 1560   
      */
 1561   
     private SetBase parseSetBase(String tagName, XmlPullParser parser, boolean strict, String encoding)
 1562   
         throws IOException, XmlPullParserException
 1563   
     {
 1564  0 
         SetBase setBase = new SetBase();
 1565  0 
         setBase.setModelEncoding( encoding );
 1566  0 
         java.util.Set parsed = new java.util.HashSet();
 1567  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 1568   
         {
 1569  0 
             if ( parser.getName().equals( "useStrictFiltering" )  )
 1570   
             {
 1571  0 
                 if ( parsed.contains( "useStrictFiltering" ) )
 1572   
                 {
 1573  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1574   
                 }
 1575  0 
                 parsed.add( "useStrictFiltering" );
 1576  0 
                 setBase.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "useStrictFiltering", parser ) );
 1577   
             }
 1578  0 
             else if ( parser.getName().equals( "useDefaultExcludes" )  )
 1579   
             {
 1580  0 
                 if ( parsed.contains( "useDefaultExcludes" ) )
 1581   
                 {
 1582  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1583   
                 }
 1584  0 
                 parsed.add( "useDefaultExcludes" );
 1585  0 
                 setBase.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText()), "useDefaultExcludes", parser ) );
 1586   
             }
 1587  0 
             else if ( parser.getName().equals( "outputDirectory" )  )
 1588   
             {
 1589  0 
                 if ( parsed.contains( "outputDirectory" ) )
 1590   
                 {
 1591  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1592   
                 }
 1593  0 
                 parsed.add( "outputDirectory" );
 1594  0 
                 setBase.setOutputDirectory( getTrimmedValue( parser.nextText()) );
 1595   
             }
 1596  0 
             else if ( parser.getName().equals( "includes" )  )
 1597   
             {
 1598  0 
                 if ( parsed.contains( "includes" ) )
 1599   
                 {
 1600  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1601   
                 }
 1602  0 
                 parsed.add( "includes" );
 1603  0 
                 java.util.List includes = new java.util.ArrayList();
 1604  0 
                 setBase.setIncludes( includes );
 1605  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1606   
                 {
 1607  0 
                     if ( parser.getName().equals( "include" ) )
 1608   
                     {
 1609  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1610   
                     }
 1611   
                     else
 1612   
                     {
 1613  0 
                         parser.nextText();
 1614   
                     }
 1615   
                 }
 1616  0 
             }
 1617  0 
             else if ( parser.getName().equals( "excludes" )  )
 1618   
             {
 1619  0 
                 if ( parsed.contains( "excludes" ) )
 1620   
                 {
 1621  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1622   
                 }
 1623  0 
                 parsed.add( "excludes" );
 1624  0 
                 java.util.List excludes = new java.util.ArrayList();
 1625  0 
                 setBase.setExcludes( excludes );
 1626  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1627   
                 {
 1628  0 
                     if ( parser.getName().equals( "exclude" ) )
 1629   
                     {
 1630  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1631   
                     }
 1632   
                     else
 1633   
                     {
 1634  0 
                         parser.nextText();
 1635   
                     }
 1636   
                 }
 1637  0 
             }
 1638  0 
             else if ( parser.getName().equals( "fileMode" )  )
 1639   
             {
 1640  0 
                 if ( parsed.contains( "fileMode" ) )
 1641   
                 {
 1642  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1643   
                 }
 1644  0 
                 parsed.add( "fileMode" );
 1645  0 
                 setBase.setFileMode( getTrimmedValue( parser.nextText()) );
 1646   
             }
 1647  0 
             else if ( parser.getName().equals( "directoryMode" )  )
 1648   
             {
 1649  0 
                 if ( parsed.contains( "directoryMode" ) )
 1650   
                 {
 1651  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1652   
                 }
 1653  0 
                 parsed.add( "directoryMode" );
 1654  0 
                 setBase.setDirectoryMode( getTrimmedValue( parser.nextText()) );
 1655   
             }
 1656   
             else
 1657   
             {
 1658  0 
                 if ( strict )
 1659   
                 {
 1660  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1661   
                 }
 1662   
             }
 1663   
         }
 1664  0 
         return setBase;
 1665   
     } //-- SetBase parseSetBase(String, XmlPullParser, boolean, String)
 1666   
 
 1667   
     /**
 1668   
      * Method parseUnpackOptions
 1669   
      *
 1670   
      * @param tagName
 1671   
      * @param encoding
 1672   
      * @param strict
 1673   
      * @param parser
 1674   
      */
 1675   
     private UnpackOptions parseUnpackOptions(String tagName, XmlPullParser parser, boolean strict, String encoding)
 1676   
         throws IOException, XmlPullParserException
 1677   
     {
 1678  0 
         UnpackOptions unpackOptions = new UnpackOptions();
 1679  0 
         unpackOptions.setModelEncoding( encoding );
 1680  0 
         java.util.Set parsed = new java.util.HashSet();
 1681  0 
         while ( parser.nextTag() == XmlPullParser.START_TAG )
 1682   
         {
 1683  0 
             if ( parser.getName().equals( "includes" )  )
 1684   
             {
 1685  0 
                 if ( parsed.contains( "includes" ) )
 1686   
                 {
 1687  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1688   
                 }
 1689  0 
                 parsed.add( "includes" );
 1690  0 
                 java.util.List includes = new java.util.ArrayList();
 1691  0 
                 unpackOptions.setIncludes( includes );
 1692  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1693   
                 {
 1694  0 
                     if ( parser.getName().equals( "include" ) )
 1695   
                     {
 1696  0 
                         includes.add( getTrimmedValue( parser.nextText()) );
 1697   
                     }
 1698   
                     else
 1699   
                     {
 1700  0 
                         parser.nextText();
 1701   
                     }
 1702   
                 }
 1703  0 
             }
 1704  0 
             else if ( parser.getName().equals( "excludes" )  )
 1705   
             {
 1706  0 
                 if ( parsed.contains( "excludes" ) )
 1707   
                 {
 1708  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1709   
                 }
 1710  0 
                 parsed.add( "excludes" );
 1711  0 
                 java.util.List excludes = new java.util.ArrayList();
 1712  0 
                 unpackOptions.setExcludes( excludes );
 1713  0 
                 while ( parser.nextTag() == XmlPullParser.START_TAG )
 1714   
                 {
 1715  0 
                     if ( parser.getName().equals( "exclude" ) )
 1716   
                     {
 1717  0 
                         excludes.add( getTrimmedValue( parser.nextText()) );
 1718   
                     }
 1719   
                     else
 1720   
                     {
 1721  0 
                         parser.nextText();
 1722   
                     }
 1723   
                 }
 1724  0 
             }
 1725  0 
             else if ( parser.getName().equals( "filtered" )  )
 1726   
             {
 1727  0 
                 if ( parsed.contains( "filtered" ) )
 1728   
                 {
 1729  0 
                     throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
 1730   
                 }
 1731  0 
                 parsed.add( "filtered" );
 1732  0 
                 unpackOptions.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText()), "filtered", parser ) );
 1733   
             }
 1734   
             else
 1735   
             {
 1736  0 
                 if ( strict )
 1737   
                 {
 1738  0 
                     throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
 1739   
                 }
 1740   
             }
 1741   
         }
 1742  0 
         return unpackOptions;
 1743   
     } //-- UnpackOptions parseUnpackOptions(String, XmlPullParser, boolean, String)
 1744   
 
 1745   
     /**
 1746   
      * Method read
 1747   
      *
 1748   
      * @param reader
 1749   
      * @param strict
 1750   
      */
 1751   
     public Assembly read(Reader reader, boolean strict)
 1752   
         throws IOException, XmlPullParserException
 1753   
     {
 1754  0 
         XmlPullParser parser = new MXParser();
 1755   
 
 1756  0 
         parser.setInput( reader );
 1757   
 
 1758  0 
         if ( addDefaultEntities )
 1759   
         {
 1760   
             // ----------------------------------------------------------------------
 1761   
             // Latin 1 entities
 1762   
             // ----------------------------------------------------------------------
 1763   
 
 1764  0 
             parser.defineEntityReplacementText( "nbsp", "\u00a0" );
 1765  0 
             parser.defineEntityReplacementText( "iexcl", "\u00a1" );
 1766  0 
             parser.defineEntityReplacementText( "cent", "\u00a2" );
 1767  0 
             parser.defineEntityReplacementText( "pound", "\u00a3" );
 1768  0 
             parser.defineEntityReplacementText( "curren", "\u00a4" );
 1769  0 
             parser.defineEntityReplacementText( "yen", "\u00a5" );
 1770  0 
             parser.defineEntityReplacementText( "brvbar", "\u00a6" );
 1771  0 
             parser.defineEntityReplacementText( "sect", "\u00a7" );
 1772  0 
             parser.defineEntityReplacementText( "uml", "\u00a8" );
 1773  0 
             parser.defineEntityReplacementText( "copy", "\u00a9" );
 1774  0 
             parser.defineEntityReplacementText( "ordf", "\u00aa" );
 1775  0 
             parser.defineEntityReplacementText( "laquo", "\u00ab" );
 1776  0 
             parser.defineEntityReplacementText( "not", "\u00ac" );
 1777  0 
             parser.defineEntityReplacementText( "shy", "\u00ad" );
 1778  0 
             parser.defineEntityReplacementText( "reg", "\u00ae" );
 1779  0 
             parser.defineEntityReplacementText( "macr", "\u00af" );
 1780  0 
             parser.defineEntityReplacementText( "deg", "\u00b0" );
 1781  0 
             parser.defineEntityReplacementText( "plusmn", "\u00b1" );
 1782  0 
             parser.defineEntityReplacementText( "sup2", "\u00b2" );
 1783  0 
             parser.defineEntityReplacementText( "sup3", "\u00b3" );
 1784  0 
             parser.defineEntityReplacementText( "acute", "\u00b4" );
 1785  0 
             parser.defineEntityReplacementText( "micro", "\u00b5" );
 1786  0 
             parser.defineEntityReplacementText( "para", "\u00b6" );
 1787  0 
             parser.defineEntityReplacementText( "middot", "\u00b7" );
 1788  0 
             parser.defineEntityReplacementText( "cedil", "\u00b8" );
 1789  0 
             parser.defineEntityReplacementText( "sup1", "\u00b9" );
 1790  0 
             parser.defineEntityReplacementText( "ordm", "\u00ba" );
 1791  0 
             parser.defineEntityReplacementText( "raquo", "\u00bb" );
 1792  0 
             parser.defineEntityReplacementText( "frac14", "\u00bc" );
 1793  0 
             parser.defineEntityReplacementText( "frac12", "\u00bd" );
 1794  0 
             parser.defineEntityReplacementText( "frac34", "\u00be" );
 1795  0 
             parser.defineEntityReplacementText( "iquest", "\u00bf" );
 1796  0 
             parser.defineEntityReplacementText( "Agrave", "\u00c0" );
 1797  0 
             parser.defineEntityReplacementText( "Aacute", "\u00c1" );
 1798  0 
             parser.defineEntityReplacementText( "Acirc", "\u00c2" );
 1799  0 
             parser.defineEntityReplacementText( "Atilde", "\u00c3" );
 1800  0 
             parser.defineEntityReplacementText( "Auml", "\u00c4" );
 1801  0 
             parser.defineEntityReplacementText( "Aring", "\u00c5" );
 1802  0 
             parser.defineEntityReplacementText( "AElig", "\u00c6" );
 1803  0 
             parser.defineEntityReplacementText( "Ccedil", "\u00c7" );
 1804  0 
             parser.defineEntityReplacementText( "Egrave", "\u00c8" );
 1805  0 
             parser.defineEntityReplacementText( "Eacute", "\u00c9" );
 1806  0 
             parser.defineEntityReplacementText( "Ecirc", "\u00ca" );
 1807  0 
             parser.defineEntityReplacementText( "Euml", "\u00cb" );
 1808  0 
             parser.defineEntityReplacementText( "Igrave", "\u00cc" );
 1809  0 
             parser.defineEntityReplacementText( "Iacute", "\u00cd" );
 1810  0 
             parser.defineEntityReplacementText( "Icirc", "\u00ce" );
 1811  0 
             parser.defineEntityReplacementText( "Iuml", "\u00cf" );
 1812  0 
             parser.defineEntityReplacementText( "ETH", "\u00d0" );
 1813  0 
             parser.defineEntityReplacementText( "Ntilde", "\u00d1" );
 1814  0 
             parser.defineEntityReplacementText( "Ograve", "\u00d2" );
 1815  0 
             parser.defineEntityReplacementText( "Oacute", "\u00d3" );
 1816  0 
             parser.defineEntityReplacementText( "Ocirc", "\u00d4" );
 1817  0 
             parser.defineEntityReplacementText( "Otilde", "\u00d5" );
 1818  0 
             parser.defineEntityReplacementText( "Ouml", "\u00d6" );
 1819  0 
             parser.defineEntityReplacementText( "times", "\u00d7" );
 1820  0 
             parser.defineEntityReplacementText( "Oslash", "\u00d8" );
 1821  0 
             parser.defineEntityReplacementText( "Ugrave", "\u00d9" );
 1822  0 
             parser.defineEntityReplacementText( "Uacute", "\u00da" );
 1823  0 
             parser.defineEntityReplacementText( "Ucirc", "\u00db" );
 1824  0 
             parser.defineEntityReplacementText( "Uuml", "\u00dc" );
 1825  0 
             parser.defineEntityReplacementText( "Yacute", "\u00dd" );
 1826  0 
             parser.defineEntityReplacementText( "THORN", "\u00de" );
 1827  0 
             parser.defineEntityReplacementText( "szlig", "\u00df" );
 1828  0 
             parser.defineEntityReplacementText( "agrave", "\u00e0" );
 1829  0 
             parser.defineEntityReplacementText( "aacute", "\u00e1" );
 1830  0 
             parser.defineEntityReplacementText( "acirc", "\u00e2" );
 1831  0 
             parser.defineEntityReplacementText( "atilde", "\u00e3" );
 1832  0 
             parser.defineEntityReplacementText( "auml", "\u00e4" );
 1833  0 
             parser.defineEntityReplacementText( "aring", "\u00e5" );
 1834  0 
             parser.defineEntityReplacementText( "aelig", "\u00e6" );
 1835  0 
             parser.defineEntityReplacementText( "ccedil", "\u00e7" );
 1836  0 
             parser.defineEntityReplacementText( "egrave", "\u00e8" );
 1837  0 
             parser.defineEntityReplacementText( "eacute", "\u00e9" );
 1838  0 
             parser.defineEntityReplacementText( "ecirc", "\u00ea" );
 1839  0 
             parser.defineEntityReplacementText( "euml", "\u00eb" );
 1840  0 
             parser.defineEntityReplacementText( "igrave", "\u00ec" );
 1841  0 
             parser.defineEntityReplacementText( "iacute", "\u00ed" );
 1842  0 
             parser.defineEntityReplacementText( "icirc", "\u00ee" );
 1843  0 
             parser.defineEntityReplacementText( "iuml", "\u00ef" );
 1844  0 
             parser.defineEntityReplacementText( "eth", "\u00f0" );
 1845  0 
             parser.defineEntityReplacementText( "ntilde", "\u00f1" );
 1846  0 
             parser.defineEntityReplacementText( "ograve", "\u00f2" );
 1847  0 
             parser.defineEntityReplacementText( "oacute", "\u00f3" );
 1848  0 
             parser.defineEntityReplacementText( "ocirc", "\u00f4" );
 1849  0 
             parser.defineEntityReplacementText( "otilde", "\u00f5" );
 1850  0 
             parser.defineEntityReplacementText( "ouml", "\u00f6" );
 1851  0 
             parser.defineEntityReplacementText( "divide", "\u00f7" );
 1852  0 
             parser.defineEntityReplacementText( "oslash", "\u00f8" );
 1853  0 
             parser.defineEntityReplacementText( "ugrave", "\u00f9" );
 1854  0 
             parser.defineEntityReplacementText( "uacute", "\u00fa" );
 1855  0 
             parser.defineEntityReplacementText( "ucirc", "\u00fb" );
 1856  0 
             parser.defineEntityReplacementText( "uuml", "\u00fc" );
 1857  0 
             parser.defineEntityReplacementText( "yacute", "\u00fd" );
 1858  0 
             parser.defineEntityReplacementText( "thorn", "\u00fe" );
 1859  0 
             parser.defineEntityReplacementText( "yuml", "\u00ff" );
 1860   
 
 1861   
             // ----------------------------------------------------------------------
 1862   
             // Special entities
 1863   
             // ----------------------------------------------------------------------
 1864   
 
 1865  0 
             parser.defineEntityReplacementText( "OElig", "\u0152" );
 1866  0 
             parser.defineEntityReplacementText( "oelig", "\u0153" );
 1867  0 
             parser.defineEntityReplacementText( "Scaron", "\u0160" );
 1868  0 
             parser.defineEntityReplacementText( "scaron", "\u0161" );
 1869  0 
             parser.defineEntityReplacementText( "Yuml", "\u0178" );
 1870  0 
             parser.defineEntityReplacementText( "circ", "\u02c6" );
 1871  0 
             parser.defineEntityReplacementText( "tilde", "\u02dc" );
 1872  0 
             parser.defineEntityReplacementText( "ensp", "\u2002" );
 1873  0 
             parser.defineEntityReplacementText( "emsp", "\u2003" );
 1874  0 
             parser.defineEntityReplacementText( "thinsp", "\u2009" );
 1875  0 
             parser.defineEntityReplacementText( "zwnj", "\u200c" );
 1876  0 
             parser.defineEntityReplacementText( "zwj", "\u200d" );
 1877  0 
             parser.defineEntityReplacementText( "lrm", "\u200e" );
 1878  0 
             parser.defineEntityReplacementText( "rlm", "\u200f" );
 1879  0 
             parser.defineEntityReplacementText( "ndash", "\u2013" );
 1880  0 
             parser.defineEntityReplacementText( "mdash", "\u2014" );
 1881  0 
             parser.defineEntityReplacementText( "lsquo", "\u2018" );
 1882  0 
             parser.defineEntityReplacementText( "rsquo", "\u2019" );
 1883  0 
             parser.defineEntityReplacementText( "sbquo", "\u201a" );
 1884  0 
             parser.defineEntityReplacementText( "ldquo", "\u201c" );
 1885  0 
             parser.defineEntityReplacementText( "rdquo", "\u201d" );
 1886  0 
             parser.defineEntityReplacementText( "bdquo", "\u201e" );
 1887  0 
             parser.defineEntityReplacementText( "dagger", "\u2020" );
 1888  0 
             parser.defineEntityReplacementText( "Dagger", "\u2021" );
 1889  0 
             parser.defineEntityReplacementText( "permil", "\u2030" );
 1890  0 
             parser.defineEntityReplacementText( "lsaquo", "\u2039" );
 1891  0 
             parser.defineEntityReplacementText( "rsaquo", "\u203a" );
 1892  0 
             parser.defineEntityReplacementText( "euro", "\u20ac" );
 1893   
 
 1894   
             // ----------------------------------------------------------------------
 1895   
             // Symbol entities
 1896   
             // ----------------------------------------------------------------------
 1897   
 
 1898  0 
             parser.defineEntityReplacementText( "fnof", "\u0192" );
 1899  0 
             parser.defineEntityReplacementText( "Alpha", "\u0391" );
 1900  0 
             parser.defineEntityReplacementText( "Beta", "\u0392" );
 1901  0 
             parser.defineEntityReplacementText( "Gamma", "\u0393" );
 1902  0 
             parser.defineEntityReplacementText( "Delta", "\u0394" );
 1903  0 
             parser.defineEntityReplacementText( "Epsilon", "\u0395" );
 1904  0 
             parser.defineEntityReplacementText( "Zeta", "\u0396" );
 1905  0 
             parser.defineEntityReplacementText( "Eta", "\u0397" );
 1906  0 
             parser.defineEntityReplacementText( "Theta", "\u0398" );
 1907  0 
             parser.defineEntityReplacementText( "Iota", "\u0399" );
 1908  0 
             parser.defineEntityReplacementText( "Kappa", "\u039a" );
 1909  0 
             parser.defineEntityReplacementText( "Lambda", "\u039b" );
 1910  0 
             parser.defineEntityReplacementText( "Mu", "\u039c" );
 1911  0 
             parser.defineEntityReplacementText( "Nu", "\u039d" );
 1912  0 
             parser.defineEntityReplacementText( "Xi", "\u039e" );
 1913  0 
             parser.defineEntityReplacementText( "Omicron", "\u039f" );
 1914  0 
             parser.defineEntityReplacementText( "Pi", "\u03a0" );
 1915  0 
             parser.defineEntityReplacementText( "Rho", "\u03a1" );
 1916  0 
             parser.defineEntityReplacementText( "Sigma", "\u03a3" );
 1917  0 
             parser.defineEntityReplacementText( "Tau", "\u03a4" );
 1918  0 
             parser.defineEntityReplacementText( "Upsilon", "\u03a5" );
 1919  0 
             parser.defineEntityReplacementText( "Phi", "\u03a6" );
 1920  0 
             parser.defineEntityReplacementText( "Chi", "\u03a7" );
 1921  0 
             parser.defineEntityReplacementText( "Psi", "\u03a8" );
 1922  0 
             parser.defineEntityReplacementText( "Omega", "\u03a9" );
 1923  0 
             parser.defineEntityReplacementText( "alpha", "\u03b1" );
 1924  0 
             parser.defineEntityReplacementText( "beta", "\u03b2" );
 1925  0 
             parser.defineEntityReplacementText( "gamma", "\u03b3" );
 1926  0 
             parser.defineEntityReplacementText( "delta", "\u03b4" );
 1927  0 
             parser.defineEntityReplacementText( "epsilon", "\u03b5" );
 1928  0 
             parser.defineEntityReplacementText( "zeta", "\u03b6" );
 1929  0 
             parser.defineEntityReplacementText( "eta", "\u03b7" );
 1930  0 
             parser.defineEntityReplacementText( "theta", "\u03b8" );
 1931  0 
             parser.defineEntityReplacementText( "iota", "\u03b9" );
 1932  0 
             parser.defineEntityReplacementText( "kappa", "\u03ba" );
 1933  0 
             parser.defineEntityReplacementText( "lambda", "\u03bb" );
 1934  0 
             parser.defineEntityReplacementText( "mu", "\u03bc" );
 1935  0 
             parser.defineEntityReplacementText( "nu", "\u03bd" );
 1936  0 
             parser.defineEntityReplacementText( "xi", "\u03be" );
 1937  0 
             parser.defineEntityReplacementText( "omicron", "\u03bf" );
 1938  0 
             parser.defineEntityReplacementText( "pi", "\u03c0" );
 1939  0 
             parser.defineEntityReplacementText( "rho", "\u03c1" );
 1940  0 
             parser.defineEntityReplacementText( "sigmaf", "\u03c2" );
 1941  0 
             parser.defineEntityReplacementText( "sigma", "\u03c3" );
 1942  0 
             parser.defineEntityReplacementText( "tau", "\u03c4" );
 1943  0 
             parser.defineEntityReplacementText( "upsilon", "\u03c5" );
 1944  0 
             parser.defineEntityReplacementText( "phi", "\u03c6" );
 1945  0 
             parser.defineEntityReplacementText( "chi", "\u03c7" );
 1946  0 
             parser.defineEntityReplacementText( "psi", "\u03c8" );
 1947  0 
             parser.defineEntityReplacementText( "omega", "\u03c9" );
 1948  0 
             parser.defineEntityReplacementText( "thetasym", "\u03d1" );
 1949  0 
             parser.defineEntityReplacementText( "upsih", "\u03d2" );
 1950  0 
             parser.defineEntityReplacementText( "piv", "\u03d6" );
 1951  0 
             parser.defineEntityReplacementText( "bull", "\u2022" );
 1952  0 
             parser.defineEntityReplacementText( "hellip", "\u2026" );
 1953  0 
             parser.defineEntityReplacementText( "prime", "\u2032" );
 1954  0 
             parser.defineEntityReplacementText( "Prime", "\u2033" );
 1955  0 
             parser.defineEntityReplacementText( "oline", "\u203e" );
 1956  0 
             parser.defineEntityReplacementText( "frasl", "\u2044" );
 1957  0 
             parser.defineEntityReplacementText( "weierp", "\u2118" );
 1958  0 
             parser.defineEntityReplacementText( "image", "\u2111" );
 1959  0 
             parser.defineEntityReplacementText( "real", "\u211c" );
 1960  0 
             parser.defineEntityReplacementText( "trade", "\u2122" );
 1961  0 
             parser.defineEntityReplacementText( "alefsym", "\u2135" );
 1962  0 
             parser.defineEntityReplacementText( "larr", "\u2190" );
 1963  0 
             parser.defineEntityReplacementText( "uarr", "\u2191" );
 1964  0 
             parser.defineEntityReplacementText( "rarr", "\u2192" );
 1965  0 
             parser.defineEntityReplacementText( "darr", "\u2193" );
 1966  0 
             parser.defineEntityReplacementText( "harr", "\u2194" );
 1967  0 
             parser.defineEntityReplacementText( "crarr", "\u21b5" );
 1968  0 
             parser.defineEntityReplacementText( "lArr", "\u21d0" );
 1969  0 
             parser.defineEntityReplacementText( "uArr", "\u21d1" );
 1970  0 
             parser.defineEntityReplacementText( "rArr", "\u21d2" );
 1971  0 
             parser.defineEntityReplacementText( "dArr", "\u21d3" );
 1972  0 
             parser.defineEntityReplacementText( "hArr", "\u21d4" );
 1973  0 
             parser.defineEntityReplacementText( "forall", "\u2200" );
 1974  0 
             parser.defineEntityReplacementText( "part", "\u2202" );
 1975  0 
             parser.defineEntityReplacementText( "exist", "\u2203" );
 1976  0 
             parser.defineEntityReplacementText( "empty", "\u2205" );
 1977  0 
             parser.defineEntityReplacementText( "nabla", "\u2207" );
 1978  0 
             parser.defineEntityReplacementText( "isin", "\u2208" );
 1979  0 
             parser.defineEntityReplacementText( "notin", "\u2209" );
 1980  0 
             parser.defineEntityReplacementText( "ni", "\u220b" );
 1981  0 
             parser.defineEntityReplacementText( "prod", "\u220f" );
 1982  0 
             parser.defineEntityReplacementText( "sum", "\u2211" );
 1983  0 
             parser.defineEntityReplacementText( "minus", "\u2212" );
 1984  0 
             parser.defineEntityReplacementText( "lowast", "\u2217" );
 1985  0 
             parser.defineEntityReplacementText( "radic", "\u221a" );
 1986  0 
             parser.defineEntityReplacementText( "prop", "\u221d" );
 1987  0 
             parser.defineEntityReplacementText( "infin", "\u221e" );
 1988  0 
             parser.defineEntityReplacementText( "ang", "\u2220" );
 1989  0 
             parser.defineEntityReplacementText( "and", "\u2227" );
 1990  0 
             parser.defineEntityReplacementText( "or", "\u2228" );
 1991  0 
             parser.defineEntityReplacementText( "cap", "\u2229" );
 1992  0 
             parser.defineEntityReplacementText( "cup", "\u222a" );
 1993  0 
             parser.defineEntityReplacementText( "int", "\u222b" );
 1994  0 
             parser.defineEntityReplacementText( "there4", "\u2234" );
 1995  0 
             parser.defineEntityReplacementText( "sim", "\u223c" );
 1996  0 
             parser.defineEntityReplacementText( "cong", "\u2245" );
 1997  0 
             parser.defineEntityReplacementText( "asymp", "\u2248" );
 1998  0 
             parser.defineEntityReplacementText( "ne", "\u2260" );
 1999  0 
             parser.defineEntityReplacementText( "equiv", "\u2261" );
 2000  0 
             parser.defineEntityReplacementText( "le", "\u2264" );
 2001  0 
             parser.defineEntityReplacementText( "ge", "\u2265" );
 2002  0 
             parser.defineEntityReplacementText( "sub", "\u2282" );
 2003  0 
             parser.defineEntityReplacementText( "sup", "\u2283" );
 2004  0 
             parser.defineEntityReplacementText( "nsub", "\u2284" );
 2005  0 
             parser.defineEntityReplacementText( "sube", "\u2286" );
 2006  0 
             parser.defineEntityReplacementText( "supe", "\u2287" );
 2007  0 
             parser.defineEntityReplacementText( "oplus", "\u2295" );
 2008  0 
             parser.defineEntityReplacementText( "otimes", "\u2297" );
 2009  0 
             parser.defineEntityReplacementText( "perp", "\u22a5" );
 2010  0 
             parser.defineEntityReplacementText( "sdot", "\u22c5" );
 2011  0 
             parser.defineEntityReplacementText( "lceil", "\u2308" );
 2012  0 
             parser.defineEntityReplacementText( "rceil", "\u2309" );
 2013  0 
             parser.defineEntityReplacementText( "lfloor", "\u230a" );
 2014  0 
             parser.defineEntityReplacementText( "rfloor", "\u230b" );
 2015  0 
             parser.defineEntityReplacementText( "lang", "\u2329" );
 2016  0 
             parser.defineEntityReplacementText( "rang", "\u232a" );
 2017  0 
             parser.defineEntityReplacementText( "loz", "\u25ca" );
 2018  0 
             parser.defineEntityReplacementText( "spades", "\u2660" );
 2019  0 
             parser.defineEntityReplacementText( "clubs", "\u2663" );
 2020  0 
             parser.defineEntityReplacementText( "hearts", "\u2665" );
 2021  0 
             parser.defineEntityReplacementText( "diams", "\u2666" );
 2022   
 
 2023   
         }
 2024   
 
 2025  0 
         parser.next();
 2026  0 
         String encoding = parser.getInputEncoding();
 2027   
 
 2028  0 
         return parseAssembly( "assembly", parser, strict, encoding );
 2029   
     } //-- Assembly read(Reader, boolean)
 2030   
 
 2031   
     /**
 2032   
      * Method read
 2033   
      *
 2034   
      * @param reader
 2035   
      */
 2036   
     public Assembly read(Reader reader)
 2037   
         throws IOException, XmlPullParserException
 2038   
     {
 2039  0 
         return read( reader, true );
 2040   
     } //-- Assembly read(Reader)
 2041   
 
 2042   
     /**
 2043   
      * Returns the state of the "add default entities" flag.
 2044   
      *
 2045   
      * @param addDefaultEntities
 2046   
      */
 2047   
     public void setAddDefaultEntities(boolean addDefaultEntities)
 2048   
     {
 2049  0 
         this.addDefaultEntities = addDefaultEntities;
 2050  0 
     } //-- void setAddDefaultEntities(boolean)
 2051   
 
 2052   
 }
Report generated by Cobertura 1.8 on 12/17/06 3:51 PM.