You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by ca...@apache.org on 2006/05/25 01:13:15 UTC
svn commit: r409264 [3/4] - in /maven/sandbox/plugins/maven-maven1-plugin:
./ src/ src/main/ src/main/java/ src/main/java/org/
src/main/java/org/apache/ src/main/java/org/apache/maven/
src/main/java/org/apache/maven/maven1converter/ src/main/java/org/a...
Added: maven/sandbox/plugins/maven-maven1-plugin/src/main/java/org/apache/maven/model/v3_0_0/io/xpp3/MavenXpp3Reader.java
URL: http://svn.apache.org/viewvc/maven/sandbox/plugins/maven-maven1-plugin/src/main/java/org/apache/maven/model/v3_0_0/io/xpp3/MavenXpp3Reader.java?rev=409264&view=auto
==============================================================================
--- maven/sandbox/plugins/maven-maven1-plugin/src/main/java/org/apache/maven/model/v3_0_0/io/xpp3/MavenXpp3Reader.java (added)
+++ maven/sandbox/plugins/maven-maven1-plugin/src/main/java/org/apache/maven/model/v3_0_0/io/xpp3/MavenXpp3Reader.java Wed May 24 16:13:13 2006
@@ -0,0 +1,2420 @@
+/*
+ * $Id$
+ */
+
+package org.apache.maven.model.v3_0_0.io.xpp3;
+
+ //---------------------------------/
+ //- Imported classes and packages -/
+//---------------------------------/
+
+import java.io.IOException;
+import java.io.Reader;
+import java.text.DateFormat;
+import java.text.ParsePosition;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import org.apache.maven.model.v3_0_0.Branch;
+import org.apache.maven.model.v3_0_0.Build;
+import org.apache.maven.model.v3_0_0.BuildBase;
+import org.apache.maven.model.v3_0_0.Contributor;
+import org.apache.maven.model.v3_0_0.Dependency;
+import org.apache.maven.model.v3_0_0.Developer;
+import org.apache.maven.model.v3_0_0.FileSet;
+import org.apache.maven.model.v3_0_0.License;
+import org.apache.maven.model.v3_0_0.MailingList;
+import org.apache.maven.model.v3_0_0.Model;
+import org.apache.maven.model.v3_0_0.ModelBase;
+import org.apache.maven.model.v3_0_0.Organization;
+import org.apache.maven.model.v3_0_0.PackageGroup;
+import org.apache.maven.model.v3_0_0.PatternSet;
+import org.apache.maven.model.v3_0_0.PluginConfiguration;
+import org.apache.maven.model.v3_0_0.PluginContainer;
+import org.apache.maven.model.v3_0_0.Repository;
+import org.apache.maven.model.v3_0_0.Resource;
+import org.apache.maven.model.v3_0_0.SourceModification;
+import org.apache.maven.model.v3_0_0.UnitTest;
+import org.apache.maven.model.v3_0_0.Version;
+import org.codehaus.plexus.util.xml.*;
+import org.codehaus.plexus.util.xml.pull.*;
+
+/**
+ * Class MavenXpp3Reader.
+ *
+ * @version $Revision$ $Date$
+ */
+public class MavenXpp3Reader {
+
+
+ //--------------------------/
+ //- Class/Member Variables -/
+ //--------------------------/
+
+ /**
+ * If set the parser till be loaded with all single characters
+ * from the XHTML specification.
+ * The entities used:
+ * <ul>
+ * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
+ * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
+ * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
+ * </ul>
+ */
+ private boolean addDefaultEntities = true;
+
+
+ //-----------/
+ //- Methods -/
+ //-----------/
+
+ /**
+ * Method getAddDefaultEntities
+ */
+ public boolean getAddDefaultEntities()
+ {
+ return addDefaultEntities;
+ } //-- boolean getAddDefaultEntities()
+
+ /**
+ * Method getBooleanValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public boolean getBooleanValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ return Boolean.valueOf( s ).booleanValue();
+ }
+ return false;
+ } //-- boolean getBooleanValue(String, String, XmlPullParser)
+
+ /**
+ * Method getCharacterValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public char getCharacterValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ return s.charAt( 0 );
+ }
+ return 0;
+ } //-- char getCharacterValue(String, String, XmlPullParser)
+
+ /**
+ * Method getDateValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public java.util.Date getDateValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ DateFormat dateParser = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL );
+ return dateParser.parse( s, new ParsePosition( 0 ) );
+ }
+ return null;
+ } //-- java.util.Date getDateValue(String, String, XmlPullParser)
+
+ /**
+ * Method getDoubleValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public double getDoubleValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ try
+ {
+ return Double.valueOf( s ).doubleValue();
+ }
+ catch ( NumberFormatException e )
+ {
+ throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
+ }
+ }
+ return 0;
+ } //-- double getDoubleValue(String, String, XmlPullParser)
+
+ /**
+ * Method getFloatValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public float getFloatValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ try
+ {
+ return Float.valueOf( s ).floatValue();
+ }
+ catch ( NumberFormatException e )
+ {
+ throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, null );
+ }
+ }
+ return 0;
+ } //-- float getFloatValue(String, String, XmlPullParser)
+
+ /**
+ * Method getIntegerValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public int getIntegerValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ try
+ {
+ return Integer.valueOf( s ).intValue();
+ }
+ catch ( NumberFormatException e )
+ {
+ throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, null );
+ }
+ }
+ return 0;
+ } //-- int getIntegerValue(String, String, XmlPullParser)
+
+ /**
+ * Method getLongValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public long getLongValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ try
+ {
+ return Long.valueOf( s ).longValue();
+ }
+ catch ( NumberFormatException e )
+ {
+ throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, null );
+ }
+ }
+ return 0;
+ } //-- long getLongValue(String, String, XmlPullParser)
+
+ /**
+ * Method getRequiredAttributeValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public String getRequiredAttributeValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s == null )
+ {
+ throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
+ }
+ return s;
+ } //-- String getRequiredAttributeValue(String, String, XmlPullParser)
+
+ /**
+ * Method getShortValue
+ *
+ * @param s
+ * @param parser
+ * @param attribute
+ */
+ public short getShortValue(String s, String attribute, XmlPullParser parser)
+ throws XmlPullParserException
+ {
+ if ( s != null )
+ {
+ try
+ {
+ return Short.valueOf( s ).shortValue();
+ }
+ catch ( NumberFormatException e )
+ {
+ throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, null );
+ }
+ }
+ return 0;
+ } //-- short getShortValue(String, String, XmlPullParser)
+
+ /**
+ * Method getTrimmedValue
+ *
+ * @param s
+ */
+ public String getTrimmedValue(String s)
+ {
+ if ( s != null )
+ {
+ s = s.trim();
+ }
+ return s;
+ } //-- String getTrimmedValue(String)
+
+ /**
+ * Method parseBranch
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Branch parseBranch(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Branch branch = new Branch();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "tag" ) )
+ {
+ if ( parsed.contains( "tag" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "tag" );
+ branch.setTag( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return branch;
+ } //-- Branch parseBranch(String, XmlPullParser)
+
+ /**
+ * Method parseBuild
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Build parseBuild(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Build build = new Build();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "nagEmailAddress" ) )
+ {
+ if ( parsed.contains( "nagEmailAddress" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "nagEmailAddress" );
+ build.setNagEmailAddress( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "sourceDirectory" ) )
+ {
+ if ( parsed.contains( "sourceDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "sourceDirectory" );
+ build.setSourceDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "unitTestSourceDirectory" ) )
+ {
+ if ( parsed.contains( "unitTestSourceDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "unitTestSourceDirectory" );
+ build.setUnitTestSourceDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "aspectSourceDirectory" ) )
+ {
+ if ( parsed.contains( "aspectSourceDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "aspectSourceDirectory" );
+ build.setAspectSourceDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "integrationUnitTestSourceDirectory" ) )
+ {
+ if ( parsed.contains( "integrationUnitTestSourceDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "integrationUnitTestSourceDirectory" );
+ build.setIntegrationUnitTestSourceDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "sourceModifications" ) )
+ {
+ if ( parsed.contains( "sourceModifications" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "sourceModifications" );
+ java.util.List sourceModifications = new java.util.ArrayList();
+ build.setSourceModifications( sourceModifications );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "sourceModification" ) )
+ {
+ sourceModifications.add( parseSourceModification( "sourceModification", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "unitTest" ) )
+ {
+ if ( parsed.contains( "unitTest" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "unitTest" );
+ build.setUnitTest( parseUnitTest( "unitTest", parser ) );
+ }
+ else if ( parser.getName().equals( "defaultGoal" ) )
+ {
+ if ( parsed.contains( "defaultGoal" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "defaultGoal" );
+ build.setDefaultGoal( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "resources" ) )
+ {
+ if ( parsed.contains( "resources" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "resources" );
+ java.util.List resources = new java.util.ArrayList();
+ build.setResources( resources );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "resource" ) )
+ {
+ resources.add( parseResource( "resource", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return build;
+ } //-- Build parseBuild(String, XmlPullParser)
+
+ /**
+ * Method parseBuildBase
+ *
+ * @param tagName
+ * @param parser
+ */
+ private BuildBase parseBuildBase(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ BuildBase buildBase = new BuildBase();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "defaultGoal" ) )
+ {
+ if ( parsed.contains( "defaultGoal" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "defaultGoal" );
+ buildBase.setDefaultGoal( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "resources" ) )
+ {
+ if ( parsed.contains( "resources" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "resources" );
+ java.util.List resources = new java.util.ArrayList();
+ buildBase.setResources( resources );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "resource" ) )
+ {
+ resources.add( parseResource( "resource", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return buildBase;
+ } //-- BuildBase parseBuildBase(String, XmlPullParser)
+
+ /**
+ * Method parseContributor
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Contributor parseContributor(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Contributor contributor = new Contributor();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ contributor.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "email" ) )
+ {
+ if ( parsed.contains( "email" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "email" );
+ contributor.setEmail( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ contributor.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" ) )
+ {
+ if ( parsed.contains( "organization" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "organization" );
+ contributor.setOrganization( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "organizationUrl" ) || parser.getName().equals( "organisationUrl" ) )
+ {
+ if ( parsed.contains( "organizationUrl" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "organizationUrl" );
+ contributor.setOrganizationUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "roles" ) )
+ {
+ if ( parsed.contains( "roles" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "roles" );
+ java.util.List roles = new java.util.ArrayList();
+ contributor.setRoles( roles );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "role" ) )
+ {
+ roles.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "timezone" ) )
+ {
+ if ( parsed.contains( "timezone" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "timezone" );
+ contributor.setTimezone( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "properties" ) )
+ {
+ if ( parsed.contains( "properties" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "properties" );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ String key = parser.getName();
+ String value = parser.nextText()
+ .trim()
+ ;
+ contributor.addProperty( key, value );
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return contributor;
+ } //-- Contributor parseContributor(String, XmlPullParser)
+
+ /**
+ * Method parseDependency
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Dependency parseDependency(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Dependency dependency = new Dependency();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "id" ) )
+ {
+ if ( parsed.contains( "id" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "id" );
+ dependency.setId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "groupId" ) )
+ {
+ if ( parsed.contains( "groupId" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "groupId" );
+ dependency.setGroupId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "artifactId" ) )
+ {
+ if ( parsed.contains( "artifactId" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "artifactId" );
+ dependency.setArtifactId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "version" ) )
+ {
+ if ( parsed.contains( "version" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "version" );
+ dependency.setVersion( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ dependency.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "jar" ) )
+ {
+ if ( parsed.contains( "jar" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "jar" );
+ dependency.setJar( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "type" ) )
+ {
+ if ( parsed.contains( "type" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "type" );
+ dependency.setType( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "properties" ) )
+ {
+ if ( parsed.contains( "properties" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "properties" );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ String key = parser.getName();
+ String value = parser.nextText()
+ .trim()
+ ;
+ dependency.addProperty( key, value );
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return dependency;
+ } //-- Dependency parseDependency(String, XmlPullParser)
+
+ /**
+ * Method parseDeveloper
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Developer parseDeveloper(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Developer developer = new Developer();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "id" ) )
+ {
+ if ( parsed.contains( "id" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "id" );
+ developer.setId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ developer.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "email" ) )
+ {
+ if ( parsed.contains( "email" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "email" );
+ developer.setEmail( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ developer.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" ) )
+ {
+ if ( parsed.contains( "organization" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "organization" );
+ developer.setOrganization( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "organizationUrl" ) || parser.getName().equals( "organisationUrl" ) )
+ {
+ if ( parsed.contains( "organizationUrl" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "organizationUrl" );
+ developer.setOrganizationUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "roles" ) )
+ {
+ if ( parsed.contains( "roles" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "roles" );
+ java.util.List roles = new java.util.ArrayList();
+ developer.setRoles( roles );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "role" ) )
+ {
+ roles.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "timezone" ) )
+ {
+ if ( parsed.contains( "timezone" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "timezone" );
+ developer.setTimezone( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "properties" ) )
+ {
+ if ( parsed.contains( "properties" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "properties" );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ String key = parser.getName();
+ String value = parser.nextText()
+ .trim()
+ ;
+ developer.addProperty( key, value );
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return developer;
+ } //-- Developer parseDeveloper(String, XmlPullParser)
+
+ /**
+ * Method parseFileSet
+ *
+ * @param tagName
+ * @param parser
+ */
+ private FileSet parseFileSet(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ FileSet fileSet = new FileSet();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "directory" ) )
+ {
+ if ( parsed.contains( "directory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "directory" );
+ fileSet.setDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "includes" ) )
+ {
+ if ( parsed.contains( "includes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "includes" );
+ java.util.List includes = new java.util.ArrayList();
+ fileSet.setIncludes( includes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "include" ) )
+ {
+ includes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "excludes" ) )
+ {
+ if ( parsed.contains( "excludes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "excludes" );
+ java.util.List excludes = new java.util.ArrayList();
+ fileSet.setExcludes( excludes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "exclude" ) )
+ {
+ excludes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return fileSet;
+ } //-- FileSet parseFileSet(String, XmlPullParser)
+
+ /**
+ * Method parseLicense
+ *
+ * @param tagName
+ * @param parser
+ */
+ private License parseLicense(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ License license = new License();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ license.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ license.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "distribution" ) )
+ {
+ if ( parsed.contains( "distribution" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "distribution" );
+ license.setDistribution( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "comments" ) )
+ {
+ if ( parsed.contains( "comments" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "comments" );
+ license.setComments( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return license;
+ } //-- License parseLicense(String, XmlPullParser)
+
+ /**
+ * Method parseMailingList
+ *
+ * @param tagName
+ * @param parser
+ */
+ private MailingList parseMailingList(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ MailingList mailingList = new MailingList();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ mailingList.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "subscribe" ) )
+ {
+ if ( parsed.contains( "subscribe" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "subscribe" );
+ mailingList.setSubscribe( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "unsubscribe" ) )
+ {
+ if ( parsed.contains( "unsubscribe" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "unsubscribe" );
+ mailingList.setUnsubscribe( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "post" ) )
+ {
+ if ( parsed.contains( "post" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "post" );
+ mailingList.setPost( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "archive" ) )
+ {
+ if ( parsed.contains( "archive" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "archive" );
+ mailingList.setArchive( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "otherArchives" ) )
+ {
+ if ( parsed.contains( "otherArchives" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "otherArchives" );
+ java.util.List otherArchives = new java.util.ArrayList();
+ mailingList.setOtherArchives( otherArchives );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "otherArchive" ) )
+ {
+ otherArchives.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return mailingList;
+ } //-- MailingList parseMailingList(String, XmlPullParser)
+
+ /**
+ * Method parseModel
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Model parseModel(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Model model = new Model();
+ java.util.Set parsed = new java.util.HashSet();
+ int eventType = parser.getEventType();
+ boolean foundRoot = false;
+ while ( eventType != XmlPullParser.END_DOCUMENT )
+ {
+ if ( eventType == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ foundRoot = true;
+ }
+ else if ( parser.getName().equals( "extend" ) )
+ {
+ if ( parsed.contains( "extend" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "extend" );
+ model.setExtend( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "pomVersion" ) )
+ {
+ if ( parsed.contains( "pomVersion" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "pomVersion" );
+ model.setPomVersion( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "id" ) )
+ {
+ if ( parsed.contains( "id" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "id" );
+ model.setId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "groupId" ) )
+ {
+ if ( parsed.contains( "groupId" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "groupId" );
+ model.setGroupId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "artifactId" ) )
+ {
+ if ( parsed.contains( "artifactId" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "artifactId" );
+ model.setArtifactId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ model.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "currentVersion" ) )
+ {
+ if ( parsed.contains( "currentVersion" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "currentVersion" );
+ model.setCurrentVersion( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "shortDescription" ) )
+ {
+ if ( parsed.contains( "shortDescription" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "shortDescription" );
+ model.setShortDescription( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "description" ) )
+ {
+ if ( parsed.contains( "description" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "description" );
+ model.setDescription( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ model.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "logo" ) )
+ {
+ if ( parsed.contains( "logo" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "logo" );
+ model.setLogo( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "issueTrackingUrl" ) )
+ {
+ if ( parsed.contains( "issueTrackingUrl" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "issueTrackingUrl" );
+ model.setIssueTrackingUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "inceptionYear" ) )
+ {
+ if ( parsed.contains( "inceptionYear" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "inceptionYear" );
+ model.setInceptionYear( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "gumpRepositoryId" ) )
+ {
+ if ( parsed.contains( "gumpRepositoryId" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "gumpRepositoryId" );
+ model.setGumpRepositoryId( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "siteAddress" ) )
+ {
+ if ( parsed.contains( "siteAddress" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "siteAddress" );
+ model.setSiteAddress( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "siteDirectory" ) )
+ {
+ if ( parsed.contains( "siteDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "siteDirectory" );
+ model.setSiteDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "distributionSite" ) )
+ {
+ if ( parsed.contains( "distributionSite" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "distributionSite" );
+ model.setDistributionSite( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "distributionDirectory" ) )
+ {
+ if ( parsed.contains( "distributionDirectory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "distributionDirectory" );
+ model.setDistributionDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "mailingLists" ) )
+ {
+ if ( parsed.contains( "mailingLists" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "mailingLists" );
+ java.util.List mailingLists = new java.util.ArrayList();
+ model.setMailingLists( mailingLists );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "mailingList" ) )
+ {
+ mailingLists.add( parseMailingList( "mailingList", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "developers" ) )
+ {
+ if ( parsed.contains( "developers" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "developers" );
+ java.util.List developers = new java.util.ArrayList();
+ model.setDevelopers( developers );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "developer" ) )
+ {
+ developers.add( parseDeveloper( "developer", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "contributors" ) )
+ {
+ if ( parsed.contains( "contributors" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "contributors" );
+ java.util.List contributors = new java.util.ArrayList();
+ model.setContributors( contributors );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "contributor" ) )
+ {
+ contributors.add( parseContributor( "contributor", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "licenses" ) )
+ {
+ if ( parsed.contains( "licenses" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "licenses" );
+ java.util.List licenses = new java.util.ArrayList();
+ model.setLicenses( licenses );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "license" ) )
+ {
+ licenses.add( parseLicense( "license", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "versions" ) )
+ {
+ if ( parsed.contains( "versions" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "versions" );
+ java.util.List versions = new java.util.ArrayList();
+ model.setVersions( versions );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "version" ) )
+ {
+ versions.add( parseVersion( "version", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "branches" ) )
+ {
+ if ( parsed.contains( "branches" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "branches" );
+ java.util.List branches = new java.util.ArrayList();
+ model.setBranches( branches );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "branch" ) )
+ {
+ branches.add( parseBranch( "branch", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "packageGroups" ) )
+ {
+ if ( parsed.contains( "packageGroups" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "packageGroups" );
+ java.util.List packageGroups = new java.util.ArrayList();
+ model.setPackageGroups( packageGroups );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "packageGroup" ) )
+ {
+ packageGroups.add( parsePackageGroup( "packageGroup", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "reports" ) )
+ {
+ if ( parsed.contains( "reports" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "reports" );
+ java.util.List reports = new java.util.ArrayList();
+ model.setReports( reports );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "report" ) )
+ {
+ reports.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "repository" ) )
+ {
+ if ( parsed.contains( "repository" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "repository" );
+ model.setRepository( parseRepository( "repository", parser ) );
+ }
+ else if ( parser.getName().equals( "organization" ) || parser.getName().equals( "organisation" ) )
+ {
+ if ( parsed.contains( "organization" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "organization" );
+ model.setOrganization( parseOrganization( "organization", parser ) );
+ }
+ else if ( parser.getName().equals( "properties" ) )
+ {
+ if ( parsed.contains( "properties" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "properties" );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ String key = parser.getName();
+ String value = parser.nextText()
+ .trim()
+ ;
+ model.addProperty( key, value );
+ }
+ }
+ else if ( parser.getName().equals( "package" ) )
+ {
+ if ( parsed.contains( "package" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "package" );
+ model.setPackageName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "build" ) )
+ {
+ if ( parsed.contains( "build" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "build" );
+ model.setBuild( parseBuild( "build", parser ) );
+ }
+ else if ( parser.getName().equals( "dependencies" ) )
+ {
+ if ( parsed.contains( "dependencies" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "dependencies" );
+ java.util.List dependencies = new java.util.ArrayList();
+ model.setDependencies( dependencies );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "dependency" ) )
+ {
+ dependencies.add( parseDependency( "dependency", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ if ( foundRoot )
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ }
+ eventType = parser.next();
+ }
+ return model;
+ } //-- Model parseModel(String, XmlPullParser)
+
+ /**
+ * Method parseModelBase
+ *
+ * @param tagName
+ * @param parser
+ */
+ private ModelBase parseModelBase(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ ModelBase modelBase = new ModelBase();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "dependencies" ) )
+ {
+ if ( parsed.contains( "dependencies" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "dependencies" );
+ java.util.List dependencies = new java.util.ArrayList();
+ modelBase.setDependencies( dependencies );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "dependency" ) )
+ {
+ dependencies.add( parseDependency( "dependency", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return modelBase;
+ } //-- ModelBase parseModelBase(String, XmlPullParser)
+
+ /**
+ * Method parseOrganization
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Organization parseOrganization(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Organization organization = new Organization();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ organization.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ organization.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "logo" ) )
+ {
+ if ( parsed.contains( "logo" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "logo" );
+ organization.setLogo( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return organization;
+ } //-- Organization parseOrganization(String, XmlPullParser)
+
+ /**
+ * Method parsePackageGroup
+ *
+ * @param tagName
+ * @param parser
+ */
+ private PackageGroup parsePackageGroup(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ PackageGroup packageGroup = new PackageGroup();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "title" ) )
+ {
+ if ( parsed.contains( "title" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "title" );
+ packageGroup.setTitle( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "packages" ) )
+ {
+ if ( parsed.contains( "packages" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "packages" );
+ packageGroup.setPackages( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return packageGroup;
+ } //-- PackageGroup parsePackageGroup(String, XmlPullParser)
+
+ /**
+ * Method parsePatternSet
+ *
+ * @param tagName
+ * @param parser
+ */
+ private PatternSet parsePatternSet(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ PatternSet patternSet = new PatternSet();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "includes" ) )
+ {
+ if ( parsed.contains( "includes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "includes" );
+ java.util.List includes = new java.util.ArrayList();
+ patternSet.setIncludes( includes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "include" ) )
+ {
+ includes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "excludes" ) )
+ {
+ if ( parsed.contains( "excludes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "excludes" );
+ java.util.List excludes = new java.util.ArrayList();
+ patternSet.setExcludes( excludes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "exclude" ) )
+ {
+ excludes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return patternSet;
+ } //-- PatternSet parsePatternSet(String, XmlPullParser)
+
+ /**
+ * Method parsePluginConfiguration
+ *
+ * @param tagName
+ * @param parser
+ */
+ private PluginConfiguration parsePluginConfiguration(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ PluginConfiguration pluginConfiguration = new PluginConfiguration();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return pluginConfiguration;
+ } //-- PluginConfiguration parsePluginConfiguration(String, XmlPullParser)
+
+ /**
+ * Method parsePluginContainer
+ *
+ * @param tagName
+ * @param parser
+ */
+ private PluginContainer parsePluginContainer(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ PluginContainer pluginContainer = new PluginContainer();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return pluginContainer;
+ } //-- PluginContainer parsePluginContainer(String, XmlPullParser)
+
+ /**
+ * Method parseRepository
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Repository parseRepository(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Repository repository = new Repository();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "connection" ) )
+ {
+ if ( parsed.contains( "connection" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "connection" );
+ repository.setConnection( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "developerConnection" ) )
+ {
+ if ( parsed.contains( "developerConnection" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "developerConnection" );
+ repository.setDeveloperConnection( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "url" ) )
+ {
+ if ( parsed.contains( "url" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "url" );
+ repository.setUrl( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return repository;
+ } //-- Repository parseRepository(String, XmlPullParser)
+
+ /**
+ * Method parseResource
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Resource parseResource(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Resource resource = new Resource();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "targetPath" ) )
+ {
+ if ( parsed.contains( "targetPath" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "targetPath" );
+ resource.setTargetPath( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "filtering" ) )
+ {
+ if ( parsed.contains( "filtering" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "filtering" );
+ resource.setFiltering( getBooleanValue( getTrimmedValue( parser.nextText()), "filtering", parser ) );
+ }
+ else if ( parser.getName().equals( "directory" ) )
+ {
+ if ( parsed.contains( "directory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "directory" );
+ resource.setDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "includes" ) )
+ {
+ if ( parsed.contains( "includes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "includes" );
+ java.util.List includes = new java.util.ArrayList();
+ resource.setIncludes( includes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "include" ) )
+ {
+ includes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "excludes" ) )
+ {
+ if ( parsed.contains( "excludes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "excludes" );
+ java.util.List excludes = new java.util.ArrayList();
+ resource.setExcludes( excludes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "exclude" ) )
+ {
+ excludes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return resource;
+ } //-- Resource parseResource(String, XmlPullParser)
+
+ /**
+ * Method parseSourceModification
+ *
+ * @param tagName
+ * @param parser
+ */
+ private SourceModification parseSourceModification(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ SourceModification sourceModification = new SourceModification();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "className" ) )
+ {
+ if ( parsed.contains( "className" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "className" );
+ sourceModification.setClassName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "property" ) )
+ {
+ if ( parsed.contains( "property" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "property" );
+ sourceModification.setProperty( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "directory" ) )
+ {
+ if ( parsed.contains( "directory" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "directory" );
+ sourceModification.setDirectory( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "includes" ) )
+ {
+ if ( parsed.contains( "includes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "includes" );
+ java.util.List includes = new java.util.ArrayList();
+ sourceModification.setIncludes( includes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "include" ) )
+ {
+ includes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "excludes" ) )
+ {
+ if ( parsed.contains( "excludes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "excludes" );
+ java.util.List excludes = new java.util.ArrayList();
+ sourceModification.setExcludes( excludes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "exclude" ) )
+ {
+ excludes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return sourceModification;
+ } //-- SourceModification parseSourceModification(String, XmlPullParser)
+
+ /**
+ * Method parseUnitTest
+ *
+ * @param tagName
+ * @param parser
+ */
+ private UnitTest parseUnitTest(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ UnitTest unitTest = new UnitTest();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "resources" ) )
+ {
+ if ( parsed.contains( "resources" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "resources" );
+ java.util.List resources = new java.util.ArrayList();
+ unitTest.setResources( resources );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "resource" ) )
+ {
+ resources.add( parseResource( "resource", parser ) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "includes" ) )
+ {
+ if ( parsed.contains( "includes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "includes" );
+ java.util.List includes = new java.util.ArrayList();
+ unitTest.setIncludes( includes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "include" ) )
+ {
+ includes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else if ( parser.getName().equals( "excludes" ) )
+ {
+ if ( parsed.contains( "excludes" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "excludes" );
+ java.util.List excludes = new java.util.ArrayList();
+ unitTest.setExcludes( excludes );
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( "exclude" ) )
+ {
+ excludes.add( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ parser.nextText();
+ }
+ }
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return unitTest;
+ } //-- UnitTest parseUnitTest(String, XmlPullParser)
+
+ /**
+ * Method parseVersion
+ *
+ * @param tagName
+ * @param parser
+ */
+ private Version parseVersion(String tagName, XmlPullParser parser)
+ throws IOException, XmlPullParserException
+ {
+ Version version = new Version();
+ java.util.Set parsed = new java.util.HashSet();
+ while ( parser.nextTag() == XmlPullParser.START_TAG )
+ {
+ if ( parser.getName().equals( tagName ) )
+ {
+ }
+ else if ( parser.getName().equals( "name" ) )
+ {
+ if ( parsed.contains( "name" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "name" );
+ version.setName( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "tag" ) )
+ {
+ if ( parsed.contains( "tag" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "tag" );
+ version.setTag( getTrimmedValue( parser.nextText()) );
+ }
+ else if ( parser.getName().equals( "id" ) )
+ {
+ if ( parsed.contains( "id" ) )
+ {
+ throw new XmlPullParserException( "Duplicated tag: '" + parser.getName() + "'", parser, null);
+ }
+ parsed.add( "id" );
+ version.setId( getTrimmedValue( parser.nextText()) );
+ }
+ else
+ {
+ throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null);
+ }
+ }
+ return version;
+ } //-- Version parseVersion(String, XmlPullParser)
+
+ /**
+ * Method read
+ *
+ * @param reader
+ */
+ public Model read(Reader reader)
+ throws IOException, XmlPullParserException
+ {
+ XmlPullParser parser = new MXParser();
+ parser.setInput( reader );
+
+ if ( addDefaultEntities )
+ {
+ // ----------------------------------------------------------------------
+ // Latin 1 entities
+ // ----------------------------------------------------------------------
+
+ parser.defineEntityReplacementText( "nbsp", "\u00a0" );
+ parser.defineEntityReplacementText( "iexcl", "\u00a1" );
+ parser.defineEntityReplacementText( "cent", "\u00a2" );
+ parser.defineEntityReplacementText( "pound", "\u00a3" );
+ parser.defineEntityReplacementText( "curren", "\u00a4" );
+ parser.defineEntityReplacementText( "yen", "\u00a5" );
+ parser.defineEntityReplacementText( "brvbar", "\u00a6" );
+ parser.defineEntityReplacementText( "sect", "\u00a7" );
+ parser.defineEntityReplacementText( "uml", "\u00a8" );
+ parser.defineEntityReplacementText( "copy", "\u00a9" );
+ parser.defineEntityReplacementText( "ordf", "\u00aa" );
+ parser.defineEntityReplacementText( "laquo", "\u00ab" );
+ parser.defineEntityReplacementText( "not", "\u00ac" );
+ parser.defineEntityReplacementText( "shy", "\u00ad" );
+ parser.defineEntityReplacementText( "reg", "\u00ae" );
+ parser.defineEntityReplacementText( "macr", "\u00af" );
+ parser.defineEntityReplacementText( "deg", "\u00b0" );
+ parser.defineEntityReplacementText( "plusmn", "\u00b1" );
+ parser.defineEntityReplacementText( "sup2", "\u00b2" );
+ parser.defineEntityReplacementText( "sup3", "\u00b3" );
+ parser.defineEntityReplacementText( "acute", "\u00b4" );
+ parser.defineEntityReplacementText( "micro", "\u00b5" );
+ parser.defineEntityReplacementText( "para", "\u00b6" );
+ parser.defineEntityReplacementText( "middot", "\u00b7" );
+ parser.defineEntityReplacementText( "cedil", "\u00b8" );
+ parser.defineEntityReplacementText( "sup1", "\u00b9" );
+ parser.defineEntityReplacementText( "ordm", "\u00ba" );
+ parser.defineEntityReplacementText( "raquo", "\u00bb" );
+ parser.defineEntityReplacementText( "frac14", "\u00bc" );
[... 247 lines stripped ...]