16:55:03.536 INFO  jd.cli.Main - Decompiling xml-apis.jar
package javax.xml;

public final class XMLConstants
{
  public static final String NULL_NS_URI = "";
  public static final String DEFAULT_NS_PREFIX = "";
  public static final String XML_NS_URI = "http://www.w3.org/XML/1998/namespace";
  public static final String XML_NS_PREFIX = "xml";
  public static final String XMLNS_ATTRIBUTE_NS_URI = "http://www.w3.org/2000/xmlns/";
  public static final String XMLNS_ATTRIBUTE = "xmlns";
  public static final String W3C_XML_SCHEMA_NS_URI = "http://www.w3.org/2001/XMLSchema";
  public static final String W3C_XML_SCHEMA_INSTANCE_NS_URI = "http://www.w3.org/2001/XMLSchema-instance";
  public static final String W3C_XPATH_DATATYPE_NS_URI = "http://www.w3.org/2003/11/xpath-datatypes";
  public static final String XML_DTD_NS_URI = "http://www.w3.org/TR/REC-xml";
  public static final String RELAXNG_NS_URI = "http://relaxng.org/ns/structure/1.0";
  public static final String FEATURE_SECURE_PROCESSING = "http://javax.xml.XMLConstants/feature/secure-processing";
}

/* Location:
 * Qualified Name:     javax.xml.XMLConstants
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.lang.reflect.Method;

public class DatatypeConfigurationException
  extends Exception
{
  private static final long serialVersionUID = -1699373159027047238L;
  private Throwable causeOnJDK13OrBelow;
  private transient boolean isJDK14OrAbove = false;
  
  public DatatypeConfigurationException() {}
  
  public DatatypeConfigurationException(String paramString)
  {
    super(paramString);
  }
  
  public DatatypeConfigurationException(String paramString, Throwable paramThrowable)
  {
    super(paramString);
    initCauseByReflection(paramThrowable);
  }
  
  public DatatypeConfigurationException(Throwable paramThrowable)
  {
    super(paramThrowable == null ? null : paramThrowable.toString());
    initCauseByReflection(paramThrowable);
  }
  
  public void printStackTrace()
  {
    if ((!isJDK14OrAbove) && (causeOnJDK13OrBelow != null)) {
      printStackTrace0(new PrintWriter(System.err, true));
    } else {
      super.printStackTrace();
    }
  }
  
  public void printStackTrace(PrintStream paramPrintStream)
  {
    if ((!isJDK14OrAbove) && (causeOnJDK13OrBelow != null)) {
      printStackTrace0(new PrintWriter(paramPrintStream));
    } else {
      super.printStackTrace(paramPrintStream);
    }
  }
  
  public void printStackTrace(PrintWriter paramPrintWriter)
  {
    if ((!isJDK14OrAbove) && (causeOnJDK13OrBelow != null)) {
      printStackTrace0(paramPrintWriter);
    } else {
      super.printStackTrace(paramPrintWriter);
    }
  }
  
  private void printStackTrace0(PrintWriter paramPrintWriter)
  {
    causeOnJDK13OrBelow.printStackTrace(paramPrintWriter);
    paramPrintWriter.println("------------------------------------------");
    super.printStackTrace(paramPrintWriter);
  }
  
  private void initCauseByReflection(Throwable paramThrowable)
  {
    causeOnJDK13OrBelow = paramThrowable;
    try
    {
      Method localMethod = getClass().getMethod("initCause", new Class[] { Throwable.class });
      localMethod.invoke(this, new Object[] { paramThrowable });
      isJDK14OrAbove = true;
    }
    catch (Exception localException) {}
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    try
    {
      Method localMethod1 = getClass().getMethod("getCause", new Class[0]);
      Throwable localThrowable = (Throwable)localMethod1.invoke(this, new Object[0]);
      if (causeOnJDK13OrBelow == null)
      {
        causeOnJDK13OrBelow = localThrowable;
      }
      else if (localThrowable == null)
      {
        Method localMethod2 = getClass().getMethod("initCause", new Class[] { Throwable.class });
        localMethod2.invoke(this, new Object[] { causeOnJDK13OrBelow });
      }
      isJDK14OrAbove = true;
    }
    catch (Exception localException) {}
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.DatatypeConfigurationException
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

class DatatypeConstants$1 {}

/* Location:
 * Qualified Name:     javax.xml.datatype.DatatypeConstants.1
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

public final class DatatypeConstants$Field
{
  private final String str;
  private final int id;
  
  private DatatypeConstants$Field(String paramString, int paramInt)
  {
    str = paramString;
    id = paramInt;
  }
  
  public String toString()
  {
    return str;
  }
  
  public int getId()
  {
    return id;
  }
  
  DatatypeConstants$Field(String paramString, int paramInt, DatatypeConstants.1 param1)
  {
    this(paramString, paramInt);
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.DatatypeConstants.Field
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import javax.xml.namespace.QName;

public final class DatatypeConstants
{
  public static final int JANUARY = 1;
  public static final int FEBRUARY = 2;
  public static final int MARCH = 3;
  public static final int APRIL = 4;
  public static final int MAY = 5;
  public static final int JUNE = 6;
  public static final int JULY = 7;
  public static final int AUGUST = 8;
  public static final int SEPTEMBER = 9;
  public static final int OCTOBER = 10;
  public static final int NOVEMBER = 11;
  public static final int DECEMBER = 12;
  public static final int LESSER = -1;
  public static final int EQUAL = 0;
  public static final int GREATER = 1;
  public static final int INDETERMINATE = 2;
  public static final int FIELD_UNDEFINED = Integer.MIN_VALUE;
  public static final Field YEARS = new Field("YEARS", 0, null);
  public static final Field MONTHS = new Field("MONTHS", 1, null);
  public static final Field DAYS = new Field("DAYS", 2, null);
  public static final Field HOURS = new Field("HOURS", 3, null);
  public static final Field MINUTES = new Field("MINUTES", 4, null);
  public static final Field SECONDS = new Field("SECONDS", 5, null);
  public static final QName DATETIME = new QName("http://www.w3.org/2001/XMLSchema", "dateTime");
  public static final QName TIME = new QName("http://www.w3.org/2001/XMLSchema", "time");
  public static final QName DATE = new QName("http://www.w3.org/2001/XMLSchema", "date");
  public static final QName GYEARMONTH = new QName("http://www.w3.org/2001/XMLSchema", "gYearMonth");
  public static final QName GMONTHDAY = new QName("http://www.w3.org/2001/XMLSchema", "gMonthDay");
  public static final QName GYEAR = new QName("http://www.w3.org/2001/XMLSchema", "gYear");
  public static final QName GMONTH = new QName("http://www.w3.org/2001/XMLSchema", "gMonth");
  public static final QName GDAY = new QName("http://www.w3.org/2001/XMLSchema", "gDay");
  public static final QName DURATION = new QName("http://www.w3.org/2001/XMLSchema", "duration");
  public static final QName DURATION_DAYTIME = new QName("http://www.w3.org/2003/11/xpath-datatypes", "dayTimeDuration");
  public static final QName DURATION_YEARMONTH = new QName("http://www.w3.org/2003/11/xpath-datatypes", "yearMonthDuration");
  public static final int MAX_TIMEZONE_OFFSET = -840;
  public static final int MIN_TIMEZONE_OFFSET = 840;
  
  public static final class Field
  {
    private final String str;
    private final int id;
    
    private Field(String paramString, int paramInt)
    {
      str = paramString;
      id = paramInt;
    }
    
    public String toString()
    {
      return str;
    }
    
    public int getId()
    {
      return id;
    }
    
    Field(String paramString, int paramInt, DatatypeConstants.1 param1)
    {
      this(paramString, paramInt);
    }
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.DatatypeConstants
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.GregorianCalendar;

public abstract class DatatypeFactory
{
  public static final String DATATYPEFACTORY_PROPERTY = "javax.xml.datatype.DatatypeFactory";
  public static final String DATATYPEFACTORY_IMPLEMENTATION_CLASS = new String("org.apache.xerces.jaxp.datatype.DatatypeFactoryImpl");
  
  public static DatatypeFactory newInstance()
    throws DatatypeConfigurationException
  {
    try
    {
      return (DatatypeFactory)FactoryFinder.find("javax.xml.datatype.DatatypeFactory", DATATYPEFACTORY_IMPLEMENTATION_CLASS);
    }
    catch (FactoryFinder.ConfigurationError localConfigurationError)
    {
      throw new DatatypeConfigurationException(localConfigurationError.getMessage(), localConfigurationError.getException());
    }
  }
  
  public static DatatypeFactory newInstance(String paramString, ClassLoader paramClassLoader)
    throws DatatypeConfigurationException
  {
    if (paramString == null) {
      throw new DatatypeConfigurationException("factoryClassName cannot be null.");
    }
    if (paramClassLoader == null) {
      paramClassLoader = SecuritySupport.getContextClassLoader();
    }
    try
    {
      return (DatatypeFactory)FactoryFinder.newInstance(paramString, paramClassLoader);
    }
    catch (FactoryFinder.ConfigurationError localConfigurationError)
    {
      throw new DatatypeConfigurationException(localConfigurationError.getMessage(), localConfigurationError.getException());
    }
  }
  
  public abstract Duration newDuration(String paramString);
  
  public abstract Duration newDuration(long paramLong);
  
  public abstract Duration newDuration(boolean paramBoolean, BigInteger paramBigInteger1, BigInteger paramBigInteger2, BigInteger paramBigInteger3, BigInteger paramBigInteger4, BigInteger paramBigInteger5, BigDecimal paramBigDecimal);
  
  public Duration newDuration(boolean paramBoolean, int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6)
  {
    BigInteger localBigInteger1 = paramInt1 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt1) : null;
    BigInteger localBigInteger2 = paramInt2 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt2) : null;
    BigInteger localBigInteger3 = paramInt3 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt3) : null;
    BigInteger localBigInteger4 = paramInt4 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt4) : null;
    BigInteger localBigInteger5 = paramInt5 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt5) : null;
    BigDecimal localBigDecimal = paramInt6 != Integer.MIN_VALUE ? BigDecimal.valueOf(paramInt6) : null;
    return newDuration(paramBoolean, localBigInteger1, localBigInteger2, localBigInteger3, localBigInteger4, localBigInteger5, localBigDecimal);
  }
  
  public Duration newDurationDayTime(String paramString)
  {
    if (paramString == null) {
      throw new NullPointerException("The lexical representation cannot be null.");
    }
    int i = paramString.indexOf('T');
    int j = i >= 0 ? i : paramString.length();
    for (int k = 0; k < j; k++)
    {
      int m = paramString.charAt(k);
      if ((m == 89) || (m == 77)) {
        throw new IllegalArgumentException("Invalid dayTimeDuration value: " + paramString);
      }
    }
    return newDuration(paramString);
  }
  
  public Duration newDurationDayTime(long paramLong)
  {
    long l1 = paramLong;
    if (l1 == 0L) {
      return newDuration(true, Integer.MIN_VALUE, Integer.MIN_VALUE, 0, 0, 0, 0);
    }
    int i = 0;
    boolean bool;
    if (l1 < 0L)
    {
      bool = false;
      if (l1 == Long.MIN_VALUE)
      {
        l1 += 1L;
        i = 1;
      }
      l1 *= -1L;
    }
    else
    {
      bool = true;
    }
    long l2 = l1;
    int j = (int)(l2 % 60000L);
    if (i != 0) {
      j++;
    }
    if (j % 1000 == 0)
    {
      int k = j / 1000;
      l2 /= 60000L;
      int m = (int)(l2 % 60L);
      l2 /= 60L;
      int n = (int)(l2 % 24L);
      long l3 = l2 / 24L;
      if (l3 <= 2147483647L) {
        return newDuration(bool, Integer.MIN_VALUE, Integer.MIN_VALUE, (int)l3, n, m, k);
      }
      return newDuration(bool, null, null, BigInteger.valueOf(l3), BigInteger.valueOf(n), BigInteger.valueOf(m), BigDecimal.valueOf(j, 3));
    }
    BigDecimal localBigDecimal = BigDecimal.valueOf(j, 3);
    l2 /= 60000L;
    BigInteger localBigInteger1 = BigInteger.valueOf(l2 % 60L);
    l2 /= 60L;
    BigInteger localBigInteger2 = BigInteger.valueOf(l2 % 24L);
    l2 /= 24L;
    BigInteger localBigInteger3 = BigInteger.valueOf(l2);
    return newDuration(bool, null, null, localBigInteger3, localBigInteger2, localBigInteger1, localBigDecimal);
  }
  
  public Duration newDurationDayTime(boolean paramBoolean, BigInteger paramBigInteger1, BigInteger paramBigInteger2, BigInteger paramBigInteger3, BigInteger paramBigInteger4)
  {
    return newDuration(paramBoolean, null, null, paramBigInteger1, paramBigInteger2, paramBigInteger3, paramBigInteger4 != null ? new BigDecimal(paramBigInteger4) : null);
  }
  
  public Duration newDurationDayTime(boolean paramBoolean, int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    return newDuration(paramBoolean, Integer.MIN_VALUE, Integer.MIN_VALUE, paramInt1, paramInt2, paramInt3, paramInt4);
  }
  
  public Duration newDurationYearMonth(String paramString)
  {
    if (paramString == null) {
      throw new NullPointerException("The lexical representation cannot be null.");
    }
    int i = paramString.length();
    for (int j = 0; j < i; j++)
    {
      int k = paramString.charAt(j);
      if ((k == 68) || (k == 84)) {
        throw new IllegalArgumentException("Invalid yearMonthDuration value: " + paramString);
      }
    }
    return newDuration(paramString);
  }
  
  public Duration newDurationYearMonth(long paramLong)
  {
    return newDuration(paramLong);
  }
  
  public Duration newDurationYearMonth(boolean paramBoolean, BigInteger paramBigInteger1, BigInteger paramBigInteger2)
  {
    return newDuration(paramBoolean, paramBigInteger1, paramBigInteger2, null, null, null, null);
  }
  
  public Duration newDurationYearMonth(boolean paramBoolean, int paramInt1, int paramInt2)
  {
    return newDuration(paramBoolean, paramInt1, paramInt2, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
  }
  
  public abstract XMLGregorianCalendar newXMLGregorianCalendar();
  
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(String paramString);
  
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(GregorianCalendar paramGregorianCalendar);
  
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(BigInteger paramBigInteger, int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, BigDecimal paramBigDecimal, int paramInt6);
  
  public XMLGregorianCalendar newXMLGregorianCalendar(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8)
  {
    BigInteger localBigInteger = paramInt1 != Integer.MIN_VALUE ? BigInteger.valueOf(paramInt1) : null;
    BigDecimal localBigDecimal = null;
    if (paramInt7 != Integer.MIN_VALUE)
    {
      if ((paramInt7 < 0) || (paramInt7 > 1000)) {
        throw new IllegalArgumentException("javax.xml.datatype.DatatypeFactory#newXMLGregorianCalendar(int year, int month, int day, int hour, int minute, int second, int millisecond, int timezone)with invalid millisecond: " + paramInt7);
      }
      localBigDecimal = BigDecimal.valueOf(paramInt7, 3);
    }
    return newXMLGregorianCalendar(localBigInteger, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, localBigDecimal, paramInt8);
  }
  
  public XMLGregorianCalendar newXMLGregorianCalendarDate(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    return newXMLGregorianCalendar(paramInt1, paramInt2, paramInt3, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, paramInt4);
  }
  
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    return newXMLGregorianCalendar(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, paramInt1, paramInt2, paramInt3, Integer.MIN_VALUE, paramInt4);
  }
  
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int paramInt1, int paramInt2, int paramInt3, BigDecimal paramBigDecimal, int paramInt4)
  {
    return newXMLGregorianCalendar(null, Integer.MIN_VALUE, Integer.MIN_VALUE, paramInt1, paramInt2, paramInt3, paramBigDecimal, paramInt4);
  }
  
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5)
  {
    BigDecimal localBigDecimal = null;
    if (paramInt4 != Integer.MIN_VALUE)
    {
      if ((paramInt4 < 0) || (paramInt4 > 1000)) {
        throw new IllegalArgumentException("javax.xml.datatype.DatatypeFactory#newXMLGregorianCalendarTime(int hours, int minutes, int seconds, int milliseconds, int timezone)with invalid milliseconds: " + paramInt4);
      }
      localBigDecimal = BigDecimal.valueOf(paramInt4, 3);
    }
    return newXMLGregorianCalendarTime(paramInt1, paramInt2, paramInt3, localBigDecimal, paramInt5);
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.DatatypeFactory
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.xml.namespace.QName;

public abstract class Duration
{
  public QName getXMLSchemaType()
  {
    boolean bool1 = isSet(DatatypeConstants.YEARS);
    boolean bool2 = isSet(DatatypeConstants.MONTHS);
    boolean bool3 = isSet(DatatypeConstants.DAYS);
    boolean bool4 = isSet(DatatypeConstants.HOURS);
    boolean bool5 = isSet(DatatypeConstants.MINUTES);
    boolean bool6 = isSet(DatatypeConstants.SECONDS);
    if ((bool1) && (bool2) && (bool3) && (bool4) && (bool5) && (bool6)) {
      return DatatypeConstants.DURATION;
    }
    if ((!bool1) && (!bool2) && (bool3) && (bool4) && (bool5) && (bool6)) {
      return DatatypeConstants.DURATION_DAYTIME;
    }
    if ((bool1) && (bool2) && (!bool3) && (!bool4) && (!bool5) && (!bool6)) {
      return DatatypeConstants.DURATION_YEARMONTH;
    }
    throw new IllegalStateException("javax.xml.datatype.Duration#getXMLSchemaType(): this Duration does not match one of the XML Schema date/time datatypes: year set = " + bool1 + " month set = " + bool2 + " day set = " + bool3 + " hour set = " + bool4 + " minute set = " + bool5 + " second set = " + bool6);
  }
  
  public abstract int getSign();
  
  public int getYears()
  {
    return getFieldValueAsInt(DatatypeConstants.YEARS);
  }
  
  public int getMonths()
  {
    return getFieldValueAsInt(DatatypeConstants.MONTHS);
  }
  
  public int getDays()
  {
    return getFieldValueAsInt(DatatypeConstants.DAYS);
  }
  
  public int getHours()
  {
    return getFieldValueAsInt(DatatypeConstants.HOURS);
  }
  
  public int getMinutes()
  {
    return getFieldValueAsInt(DatatypeConstants.MINUTES);
  }
  
  public int getSeconds()
  {
    return getFieldValueAsInt(DatatypeConstants.SECONDS);
  }
  
  public long getTimeInMillis(Calendar paramCalendar)
  {
    Calendar localCalendar = (Calendar)paramCalendar.clone();
    addTo(localCalendar);
    return getCalendarTimeInMillis(localCalendar) - getCalendarTimeInMillis(paramCalendar);
  }
  
  public long getTimeInMillis(Date paramDate)
  {
    GregorianCalendar localGregorianCalendar = new GregorianCalendar();
    localGregorianCalendar.setTime(paramDate);
    addTo(localGregorianCalendar);
    return getCalendarTimeInMillis(localGregorianCalendar) - paramDate.getTime();
  }
  
  public abstract Number getField(DatatypeConstants.Field paramField);
  
  private int getFieldValueAsInt(DatatypeConstants.Field paramField)
  {
    Number localNumber = getField(paramField);
    if (localNumber != null) {
      return localNumber.intValue();
    }
    return 0;
  }
  
  public abstract boolean isSet(DatatypeConstants.Field paramField);
  
  public abstract Duration add(Duration paramDuration);
  
  public abstract void addTo(Calendar paramCalendar);
  
  public void addTo(Date paramDate)
  {
    if (paramDate == null) {
      throw new NullPointerException("Cannot call " + getClass().getName() + "#addTo(Date date) with date == null.");
    }
    GregorianCalendar localGregorianCalendar = new GregorianCalendar();
    localGregorianCalendar.setTime(paramDate);
    addTo(localGregorianCalendar);
    paramDate.setTime(getCalendarTimeInMillis(localGregorianCalendar));
  }
  
  public Duration subtract(Duration paramDuration)
  {
    return add(paramDuration.negate());
  }
  
  public Duration multiply(int paramInt)
  {
    return multiply(BigDecimal.valueOf(paramInt));
  }
  
  public abstract Duration multiply(BigDecimal paramBigDecimal);
  
  public abstract Duration negate();
  
  public abstract Duration normalizeWith(Calendar paramCalendar);
  
  public abstract int compare(Duration paramDuration);
  
  public boolean isLongerThan(Duration paramDuration)
  {
    return compare(paramDuration) == 1;
  }
  
  public boolean isShorterThan(Duration paramDuration)
  {
    return compare(paramDuration) == -1;
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    if ((paramObject instanceof Duration)) {
      return compare((Duration)paramObject) == 0;
    }
    return false;
  }
  
  public abstract int hashCode();
  
  public String toString()
  {
    StringBuffer localStringBuffer = new StringBuffer();
    if (getSign() < 0) {
      localStringBuffer.append('-');
    }
    localStringBuffer.append('P');
    BigInteger localBigInteger1 = (BigInteger)getField(DatatypeConstants.YEARS);
    if (localBigInteger1 != null) {
      localStringBuffer.append(localBigInteger1).append('Y');
    }
    BigInteger localBigInteger2 = (BigInteger)getField(DatatypeConstants.MONTHS);
    if (localBigInteger2 != null) {
      localStringBuffer.append(localBigInteger2).append('M');
    }
    BigInteger localBigInteger3 = (BigInteger)getField(DatatypeConstants.DAYS);
    if (localBigInteger3 != null) {
      localStringBuffer.append(localBigInteger3).append('D');
    }
    BigInteger localBigInteger4 = (BigInteger)getField(DatatypeConstants.HOURS);
    BigInteger localBigInteger5 = (BigInteger)getField(DatatypeConstants.MINUTES);
    BigDecimal localBigDecimal = (BigDecimal)getField(DatatypeConstants.SECONDS);
    if ((localBigInteger4 != null) || (localBigInteger5 != null) || (localBigDecimal != null))
    {
      localStringBuffer.append('T');
      if (localBigInteger4 != null) {
        localStringBuffer.append(localBigInteger4).append('H');
      }
      if (localBigInteger5 != null) {
        localStringBuffer.append(localBigInteger5).append('M');
      }
      if (localBigDecimal != null) {
        localStringBuffer.append(toString(localBigDecimal)).append('S');
      }
    }
    return localStringBuffer.toString();
  }
  
  private String toString(BigDecimal paramBigDecimal)
  {
    String str = paramBigDecimal.unscaledValue().toString();
    int i = paramBigDecimal.scale();
    if (i == 0) {
      return str;
    }
    int j = str.length() - i;
    if (j == 0) {
      return "0." + str;
    }
    StringBuffer localStringBuffer;
    if (j > 0)
    {
      localStringBuffer = new StringBuffer(str);
      localStringBuffer.insert(j, '.');
    }
    else
    {
      localStringBuffer = new StringBuffer(3 - j + str.length());
      localStringBuffer.append("0.");
      for (int k = 0; k < -j; k++) {
        localStringBuffer.append('0');
      }
      localStringBuffer.append(str);
    }
    return localStringBuffer.toString();
  }
  
  private static long getCalendarTimeInMillis(Calendar paramCalendar)
  {
    return paramCalendar.getTime().getTime();
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.Duration
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

class FactoryFinder$ConfigurationError
  extends Error
{
  private static final long serialVersionUID = -3644413026244211347L;
  private Exception exception;
  
  FactoryFinder$ConfigurationError(String paramString, Exception paramException)
  {
    super(paramString);
    exception = paramException;
  }
  
  Exception getException()
  {
    return exception;
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.FactoryFinder.ConfigurationError
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.util.Properties;

final class FactoryFinder
{
  private static final String CLASS_NAME = "javax.xml.datatype.FactoryFinder";
  private static boolean debug = false;
  private static Properties cacheProps = new Properties();
  private static boolean firstTime = true;
  private static final int DEFAULT_LINE_LENGTH = 80;
  
  private static void debugPrintln(String paramString)
  {
    if (debug) {
      System.err.println("javax.xml.datatype.FactoryFinder:" + paramString);
    }
  }
  
  private static ClassLoader findClassLoader()
    throws FactoryFinder.ConfigurationError
  {
    ClassLoader localClassLoader = SecuritySupport.getContextClassLoader();
    if (debug) {
      debugPrintln("Using context class loader: " + localClassLoader);
    }
    if (localClassLoader == null)
    {
      localClassLoader = FactoryFinder.class.getClassLoader();
      if (debug) {
        debugPrintln("Using the class loader of FactoryFinder: " + localClassLoader);
      }
    }
    return localClassLoader;
  }
  
  static Object newInstance(String paramString, ClassLoader paramClassLoader)
    throws FactoryFinder.ConfigurationError
  {
    try
    {
      Class localClass;
      if (paramClassLoader == null) {
        localClass = Class.forName(paramString);
      } else {
        localClass = paramClassLoader.loadClass(paramString);
      }
      if (debug) {
        debugPrintln("Loaded " + paramString + " from " + which(localClass));
      }
      return localClass.newInstance();
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new ConfigurationError("Provider " + paramString + " not found", localClassNotFoundException);
    }
    catch (Exception localException)
    {
      throw new ConfigurationError("Provider " + paramString + " could not be instantiated: " + localException, localException);
    }
  }
  
  static Object find(String paramString1, String paramString2)
    throws FactoryFinder.ConfigurationError
  {
    ClassLoader localClassLoader = findClassLoader();
    try
    {
      String str1 = SecuritySupport.getSystemProperty(paramString1);
      if ((str1 != null) && (str1.length() > 0))
      {
        if (debug) {
          debugPrintln("found " + str1 + " in the system property " + paramString1);
        }
        return newInstance(str1, localClassLoader);
      }
    }
    catch (SecurityException localSecurityException) {}
    try
    {
      String str2 = SecuritySupport.getSystemProperty("java.home");
      String str3 = str2 + File.separator + "lib" + File.separator + "jaxp.properties";
      String str4 = null;
      if (firstTime) {
        synchronized (cacheProps)
        {
          if (firstTime)
          {
            File localFile = new File(str3);
            firstTime = false;
            if (SecuritySupport.doesFileExist(localFile))
            {
              if (debug) {
                debugPrintln("Read properties file " + localFile);
              }
              cacheProps.load(SecuritySupport.getFileInputStream(localFile));
            }
          }
        }
      }
      str4 = cacheProps.getProperty(paramString1);
      if (debug) {
        debugPrintln("found " + str4 + " in $java.home/jaxp.properties");
      }
      if (str4 != null) {
        return newInstance(str4, localClassLoader);
      }
    }
    catch (Exception localException)
    {
      if (debug) {
        localException.printStackTrace();
      }
    }
    Object localObject1 = findJarServiceProvider(paramString1);
    if (localObject1 != null) {
      return localObject1;
    }
    if (paramString2 == null) {
      throw new ConfigurationError("Provider for " + paramString1 + " cannot be found", null);
    }
    if (debug) {
      debugPrintln("loaded from fallback value: " + paramString2);
    }
    return newInstance(paramString2, localClassLoader);
  }
  
  private static Object findJarServiceProvider(String paramString)
    throws FactoryFinder.ConfigurationError
  {
    String str1 = "META-INF/services/" + paramString;
    InputStream localInputStream = null;
    ClassLoader localClassLoader = SecuritySupport.getContextClassLoader();
    if (localClassLoader != null)
    {
      localInputStream = SecuritySupport.getResourceAsStream(localClassLoader, str1);
      if (localInputStream == null)
      {
        localClassLoader = FactoryFinder.class.getClassLoader();
        localInputStream = SecuritySupport.getResourceAsStream(localClassLoader, str1);
      }
    }
    else
    {
      localClassLoader = FactoryFinder.class.getClassLoader();
      localInputStream = SecuritySupport.getResourceAsStream(localClassLoader, str1);
    }
    if (localInputStream == null) {
      return null;
    }
    if (debug) {
      debugPrintln("found jar resource=" + str1 + " using ClassLoader: " + localClassLoader);
    }
    BufferedReader localBufferedReader;
    try
    {
      localBufferedReader = new BufferedReader(new InputStreamReader(localInputStream, "UTF-8"), 80);
    }
    catch (UnsupportedEncodingException localUnsupportedEncodingException)
    {
      localBufferedReader = new BufferedReader(new InputStreamReader(localInputStream), 80);
    }
    String str2 = null;
    try
    {
      str2 = localBufferedReader.readLine();
    }
    catch (IOException localIOException1)
    {
      Object localObject1 = null;
      return localObject1;
    }
    finally
    {
      try
      {
        localBufferedReader.close();
      }
      catch (IOException localIOException2) {}
    }
    if ((str2 != null) && (!"".equals(str2)))
    {
      if (debug) {
        debugPrintln("found in resource, value=" + str2);
      }
      return newInstance(str2, localClassLoader);
    }
    return null;
  }
  
  private static String which(Class paramClass)
  {
    try
    {
      String str = paramClass.getName().replace('.', '/') + ".class";
      ClassLoader localClassLoader = paramClass.getClassLoader();
      URL localURL;
      if (localClassLoader != null) {
        localURL = localClassLoader.getResource(str);
      } else {
        localURL = ClassLoader.getSystemResource(str);
      }
      if (localURL != null) {
        return localURL.toString();
      }
    }
    catch (VirtualMachineError localVirtualMachineError)
    {
      throw localVirtualMachineError;
    }
    catch (ThreadDeath localThreadDeath)
    {
      throw localThreadDeath;
    }
    catch (Throwable localThrowable)
    {
      if (debug) {
        localThrowable.printStackTrace();
      }
    }
    return "unknown location";
  }
  
  static
  {
    try
    {
      String str = SecuritySupport.getSystemProperty("jaxp.debug");
      debug = (str != null) && (!"false".equals(str));
    }
    catch (Exception localException)
    {
      debug = false;
    }
  }
  
  static class ConfigurationError
    extends Error
  {
    private static final long serialVersionUID = -3644413026244211347L;
    private Exception exception;
    
    ConfigurationError(String paramString, Exception paramException)
    {
      super();
      exception = paramException;
    }
    
    Exception getException()
    {
      return exception;
    }
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.FactoryFinder
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.security.PrivilegedAction;

class SecuritySupport$1
  implements PrivilegedAction
{
  public Object run()
  {
    ClassLoader localClassLoader = null;
    try
    {
      localClassLoader = Thread.currentThread().getContextClassLoader();
    }
    catch (SecurityException localSecurityException) {}
    return localClassLoader;
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport.1
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.security.PrivilegedAction;

class SecuritySupport$2
  implements PrivilegedAction
{
  private final String val$propName;
  
  SecuritySupport$2(String paramString)
  {
    val$propName = paramString;
  }
  
  public Object run()
  {
    return System.getProperty(val$propName);
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport.2
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.security.PrivilegedExceptionAction;

class SecuritySupport$3
  implements PrivilegedExceptionAction
{
  private final File val$file;
  
  SecuritySupport$3(File paramFile)
  {
    val$file = paramFile;
  }
  
  public Object run()
    throws FileNotFoundException
  {
    return new FileInputStream(val$file);
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport.3
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.InputStream;
import java.security.PrivilegedAction;

class SecuritySupport$4
  implements PrivilegedAction
{
  private final ClassLoader val$cl;
  private final String val$name;
  
  SecuritySupport$4(ClassLoader paramClassLoader, String paramString)
  {
    val$cl = paramClassLoader;
    val$name = paramString;
  }
  
  public Object run()
  {
    InputStream localInputStream;
    if (val$cl == null) {
      localInputStream = ClassLoader.getSystemResourceAsStream(val$name);
    } else {
      localInputStream = val$cl.getResourceAsStream(val$name);
    }
    return localInputStream;
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport.4
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.File;
import java.security.PrivilegedAction;

class SecuritySupport$5
  implements PrivilegedAction
{
  private final File val$f;
  
  SecuritySupport$5(File paramFile)
  {
    val$f = paramFile;
  }
  
  public Object run()
  {
    return val$f.exists() ? Boolean.TRUE : Boolean.FALSE;
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport.5
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;

final class SecuritySupport
{
  static ClassLoader getContextClassLoader()
  {
    (ClassLoader)AccessController.doPrivileged(new PrivilegedAction()
    {
      public Object run()
      {
        ClassLoader localClassLoader = null;
        try
        {
          localClassLoader = Thread.currentThread().getContextClassLoader();
        }
        catch (SecurityException localSecurityException) {}
        return localClassLoader;
      }
    });
  }
  
  static String getSystemProperty(String paramString)
  {
    (String)AccessController.doPrivileged(new PrivilegedAction()
    {
      private final String val$propName;
      
      public Object run()
      {
        return System.getProperty(val$propName);
      }
    });
  }
  
  static FileInputStream getFileInputStream(File paramFile)
    throws FileNotFoundException
  {
    try
    {
      (FileInputStream)AccessController.doPrivileged(new PrivilegedExceptionAction()
      {
        private final File val$file;
        
        public Object run()
          throws FileNotFoundException
        {
          return new FileInputStream(val$file);
        }
      });
    }
    catch (PrivilegedActionException localPrivilegedActionException)
    {
      throw ((FileNotFoundException)localPrivilegedActionException.getException());
    }
  }
  
  static InputStream getResourceAsStream(ClassLoader paramClassLoader, String paramString)
  {
    (InputStream)AccessController.doPrivileged(new PrivilegedAction()
    {
      private final ClassLoader val$cl;
      private final String val$name;
      
      public Object run()
      {
        InputStream localInputStream;
        if (val$cl == null) {
          localInputStream = ClassLoader.getSystemResourceAsStream(val$name);
        } else {
          localInputStream = val$cl.getResourceAsStream(val$name);
        }
        return localInputStream;
      }
    });
  }
  
  static boolean doesFileExist(File paramFile)
  {
    ((Boolean)AccessController.doPrivileged(new PrivilegedAction()
    {
      private final File val$f;
      
      public Object run()
      {
        return val$f.exists() ? Boolean.TRUE : Boolean.FALSE;
      }
    })).booleanValue();
  }
}

/* Location:
 * Qualified Name:     javax.xml.datatype.SecuritySupport
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package javax.xml.datatype;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
import javax.xml.namespace.QName;

public abstract class XMLGregorianCalendar
  implements Cloneable
{
  public abstract void clear();
  
  public abstract void reset();
  
  public abstract void setYear(BigInteger paramBigInteger);
  
  public abstract void setYear(int paramInt);
  
  public abstract void setMonth(int paramInt);
  
  public abstract void setDay(int paramInt);
  
  public abstract void setTimezone(int paramInt);
  
  public void setTime(int paramInt1, int paramInt2, int paramInt3)
  {
    setTime(paramInt1, paramInt2, paramInt3, null);
  }
  
  public abstract void setHour(int paramInt);
  
  public abstract void setMinute(int paramInt);
  
  public abstract void setSecond(int paramInt);
  
  public abstract void setMillisecond(int paramInt);
  
  public abstract void setFractionalSecond(BigDecimal paramBigDecimal);
  
  public void setTime(int paramInt1, int paramInt2, int paramInt3, BigDecimal paramBigDecimal)
  {
    setHour(paramInt1);
    setMinute(paramInt2);
    setSecond(paramInt3);
    setFractionalSecond(paramBigDecimal);
  }
  
  public void setTime(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    setHour(paramInt1);
    setMinute(paramInt2);
    setSecond(paramInt3);
    setMillisecond(paramInt4);
  }
  
  public abstract BigInteger getEon();
  
  public abstract int getYear();
  
  public abstract BigInteger getEonAndYear();
  
  public abstract int getMonth();
  
  public abstract int getDay();
  
  public abstract int getTimezone();
  
  public abstract int getHour();
  
  public abstract int getMinute();
  
  public abstract int getSecond();
  
  public int getMillisecond()
  {
    BigDecimal localBigDecimal = getFractionalSecond();
    if (localBigDecimal == null) {
      return Integer.MIN_VALUE;
    }
    return getFractionalSecond().movePointRight(3).intValue();
  }
  
  public abstract