URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [xml/] [datatype/] [DatatypeFactory.java] - Blame information for rev 772

Details | Compare with Previous | View Log


/* DatatypeFactory.java --
   Copyright (C) 2004, 2005, 2006  Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
package javax.xml.datatype;
 
import java.io.File;
import java.io.FileInputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.Properties;
import java.util.ServiceLoader;
 
/**
 * Factory class to create new datatype objects mapping XML to and from Java
 * objects.
 *
 * @author Chris Burdess
 * @since 1.5
 */
public abstract class DatatypeFactory
{
 
  /**
   * JAXP 1.3 default property name.
   */
  public static final String DATATYPEFACTORY_PROPERTY = "javax.xml.datatype.DatatypeFactory";
 
  /**
   * JAXP 1.3 default implementation class name.
   */
  public static final String DATATYPEFACTORY_IMPLEMENTATION_CLASS = "gnu.xml.datatype.JAXPDatatypeFactory";
 
  protected DatatypeFactory()
  {
  }
 
  /**
   * Returns a new factory instance.
   */
  public static DatatypeFactory newInstance()
    throws DatatypeConfigurationException
  {
    try
      {
        // 1. system property
        String className = System.getProperty(DATATYPEFACTORY_PROPERTY);
        if (className != null)
          return (DatatypeFactory) Class.forName(className).newInstance();
        // 2. jaxp.properties property
        File javaHome = new File(System.getProperty("java.home"));
        File javaHomeLib = new File(javaHome, "lib");
        File jaxpProperties = new File(javaHomeLib, "jaxp.properties");
        if (jaxpProperties.exists())
          {
            FileInputStream in = new FileInputStream(jaxpProperties);
            Properties p = new Properties();
            p.load(in);
            in.close();
            className = p.getProperty(DATATYPEFACTORY_PROPERTY);
            if (className != null)
              return (DatatypeFactory) Class.forName(className).newInstance();
          }
        // 3. services
        Iterator<DatatypeFactory> i = ServiceLoader.load(DatatypeFactory.class).iterator();
        if (i.hasNext())
          return i.next();
        // 4. fallback
        Class<?> t = Class.forName(DATATYPEFACTORY_IMPLEMENTATION_CLASS);
        return (DatatypeFactory) t.newInstance();
      }
    catch (Exception e)
      {
        throw new DatatypeConfigurationException(e);
      }
  }
 
  /**
   * Returns a new duration from its string representation.
   * @param lexicalRepresentation the lexical representation of the
   * duration, as specified in XML Schema 1.0 section 3.2.6.1.
   */
  public abstract Duration newDuration(String lexicalRepresentation);
 
  /**
   * Returns a new duration.
   * @param durationInMilliSeconds the duration in milliseconds
   */
  public abstract Duration newDuration(long durationInMilliSeconds);
 
  /**
   * Returns a new duration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param years the number of years
   * @param months the number of months
   * @param days the number of days
   * @param hours the number of hours
   * @param minutes th number of minutes
   * @param seconds the number of seconds
   */
  public abstract Duration newDuration(boolean isPositive,
                                       BigInteger years,
                                       BigInteger months,
                                       BigInteger days,
                                       BigInteger hours,
                                       BigInteger minutes,
                                       BigDecimal seconds);
 
  /**
   * Returns a new duration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param years the number of years
   * @param months the number of months
   * @param days the number of days
   * @param hours the number of hours
   * @param minutes th number of minutes
   * @param seconds the number of seconds
   */
  public Duration newDuration(boolean isPositive,
                              int years,
                              int months,
                              int days,
                              int hours,
                              int minutes,
                              int seconds)
  {
    return newDuration(isPositive,
                       BigInteger.valueOf((long) years),
                       BigInteger.valueOf((long) months),
                       BigInteger.valueOf((long) days),
                       BigInteger.valueOf((long) hours),
                       BigInteger.valueOf((long) minutes),
                       BigDecimal.valueOf((long) seconds));
  }
 
  /**
   * Returns a new dayTimeDuration from its string representation.
   * @param lexicalRepresentation the lexical representation of the
   * duration, as specified in XML Schema 1.0 section 3.2.6.1.
   */
  public Duration newDurationDayTime(String lexicalRepresentation)
  {
    return newDuration(lexicalRepresentation);
  }
 
  /**
   * Returns a new dayTimeDuration.
   * @param durationInMilliseconds the duration in milliseconds
   */
  public Duration newDurationDayTime(long durationInMilliseconds)
  {
    // TODO xmlSchemaType
    return newDuration(durationInMilliseconds);
  }
 
  /**
   * Returns a new dayTimeDuration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param days the number of days
   * @param hours the number of hours
   * @param minutes th number of minutes
   * @param seconds the number of seconds
   */
  public Duration newDurationDayTime(boolean isPositive,
                                     BigInteger days,
                                     BigInteger hours,
                                     BigInteger minutes,
                                     BigInteger seconds)
  {
    return newDuration(isPositive,
                       null,
                       null,
                       days,
                       hours,
                       minutes,
                       new BigDecimal(seconds));
  }
 
  /**
   * Returns a new dayTimeDuration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param days the number of days
   * @param hours the number of hours
   * @param minutes th number of minutes
   * @param seconds the number of seconds
   */
  public Duration newDurationDayTime(boolean isPositive,
                                     int days,
                                     int hours,
                                     int minutes,
                                     int seconds)
  {
    return newDuration(isPositive,
                       null,
                       null,
                       BigInteger.valueOf((long) days),
                       BigInteger.valueOf((long) hours),
                       BigInteger.valueOf((long) minutes),
                       BigDecimal.valueOf((long) seconds));
  }
 
  /**
   * Returns a new yearMonthDuration from its string representation.
   * @param lexicalRepresentation the lexical representation of the
   * duration, as specified in XML Schema 1.0 section 3.2.6.1.
   */
  public Duration newDurationYearMonth(String lexicalRepresentation)
  {
    return newDuration(lexicalRepresentation);
  }
 
  /**
   * Returns a new yearMonthDuration.
   * @param durationInMilliseconds the duration in milliseconds
   */
  public Duration newDurationYearMonth(long durationInMilliseconds)
  {
    // TODO xmlSchemaType
    return newDuration(durationInMilliseconds);
  }
 
  /**
   * Returns a new yearMonthDuration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param years the number of years
   * @param months the number of months
   */
  public Duration newDurationYearMonth(boolean isPositive,
                                       BigInteger years,
                                       BigInteger months)
  {
    return newDuration(isPositive,
                       years,
                       months,
                       null,
                       null,
                       null,
                       null);
  }
 
  /**
   * Returns a new yearMonthDuration by specifying the individual components.
   * @param isPositive whether the duration is positive
   * @param years the number of years
   * @param months the number of months
   */
  public Duration newDurationYearMonth(boolean isPositive,
                                       int years,
                                       int months)
  {
    return newDuration(isPositive,
                       BigInteger.valueOf((long) years),
                       BigInteger.valueOf((long) months),
                       null,
                       null,
                       null,
                       null);
  }
 
  /**
   * Returns a new XMLGregorianCalendar with no fields initialized.
   */
  public abstract XMLGregorianCalendar newXMLGregorianCalendar();
 
  /**
   * Returns a new XMLGregorianCalendar from a string representation.
   * @param lexicalRepresentation the lexical representation as specified in
   * XML Schema 1.0 Part 2, section 3.2.[7-14].1.
   */
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(String lexicalRepresentation);
 
  /**
   * Returns a new XMLGregorianCalendar based on the specified Gregorian
   * calendar.
   */
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(GregorianCalendar cal);
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public abstract XMLGregorianCalendar newXMLGregorianCalendar(BigInteger year,
                                                               int month,
                                                               int day,
                                                               int hour,
                                                               int minute,
                                                               int second,
                                                               BigDecimal fractionalSecond,
                                                               int timezone);
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public XMLGregorianCalendar newXMLGregorianCalendar(int year,
                                                      int month,
                                                      int day,
                                                      int hour,
                                                      int minute,
                                                      int second,
                                                      int millisecond,
                                                      int timezone)
  {
    return newXMLGregorianCalendar(BigInteger.valueOf((long) year),
                                   month,
                                   day,
                                   hour,
                                   minute,
                                   second,
                                   new BigDecimal(((double) millisecond) / 1000.0),
                                   timezone);
  }
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public XMLGregorianCalendar newXMLGregorianCalendarDate(int year,
                                                          int month,
                                                          int day,
                                                          int timezone)
  {
    return newXMLGregorianCalendar(BigInteger.valueOf((long) year),
                                   month,
                                   day,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   null,
                                   timezone);
  }
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,
                                                          int minutes,
                                                          int seconds,
                                                          int timezone)
  {
    return newXMLGregorianCalendar(null,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   hours,
                                   minutes,
                                   seconds,
                                   null,
                                   timezone);
  }
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,
                                                          int minutes,
                                                          int seconds,
                                                          BigDecimal fractionalSecond,
                                                          int timezone)
  {
    return newXMLGregorianCalendar(null,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   hours,
                                   minutes,
                                   seconds,
                                   fractionalSecond,
                                   timezone);
  }
 
  /**
   * Returns a new XMLGregorianCalendar with the specified components.
   */
  public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,
                                                          int minutes,
                                                          int seconds,
                                                          int milliseconds,
                                                          int timezone)
  {
    return newXMLGregorianCalendar(null,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   DatatypeConstants.FIELD_UNDEFINED,
                                   hours,
                                   minutes,
                                   seconds,
                                   new BigDecimal(((double) milliseconds) / 1000.0),
                                   timezone);
  }
 
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [xml/] [datatype/] [DatatypeFactory.java] - Blame information for rev 772

Line No.	Rev	Author	Line
1	772	jeremybenn	`/* DatatypeFactory.java --`
2			`Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.`
3
4			`This file is part of GNU Classpath.`
5
6			`GNU Classpath is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2, or (at your option)`
9			`any later version.`
10
11			`GNU Classpath is distributed in the hope that it will be useful, but`
12			`WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
14			`General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with GNU Classpath; see the file COPYING. If not, write to the`
18			`Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA`
19			`02110-1301 USA.`
20
21			`Linking this library statically or dynamically with other modules is`
22			`making a combined work based on this library. Thus, the terms and`
23			`conditions of the GNU General Public License cover the whole`
24			`combination.`
25
26			`As a special exception, the copyright holders of this library give you`
27			`permission to link this library with independent modules to produce an`
28			`executable, regardless of the license terms of these independent`
29			`modules, and to copy and distribute the resulting executable under`
30			`terms of your choice, provided that you also meet, for each linked`
31			`independent module, the terms and conditions of the license of that`
32			`module. An independent module is a module which is not derived from`
33			`or based on this library. If you modify this library, you may extend`
34			`this exception to your version of the library, but you are not`
35			`obligated to do so. If you do not wish to do so, delete this`
36			`exception statement from your version. */`
37
38			`package javax.xml.datatype;`
39
40			`import java.io.File;`
41			`import java.io.FileInputStream;`
42			`import java.math.BigDecimal;`
43			`import java.math.BigInteger;`
44			`import java.util.GregorianCalendar;`
45			`import java.util.Iterator;`
46			`import java.util.Properties;`
47			`import java.util.ServiceLoader;`
48
49			`/**`
50			`* Factory class to create new datatype objects mapping XML to and from Java`
51			`* objects.`
52			`*`
53			`* @author Chris Burdess`
54			`* @since 1.5`
55			`*/`
56			`public abstract class DatatypeFactory`
57			`{`
58
59			`/**`
60			`* JAXP 1.3 default property name.`
61			`*/`
62			`public static final String DATATYPEFACTORY_PROPERTY = "javax.xml.datatype.DatatypeFactory";`
63
64			`/**`
65			`* JAXP 1.3 default implementation class name.`
66			`*/`
67			`public static final String DATATYPEFACTORY_IMPLEMENTATION_CLASS = "gnu.xml.datatype.JAXPDatatypeFactory";`
68
69			`protected DatatypeFactory()`
70			`{`
71			`}`
72
73			`/**`
74			`* Returns a new factory instance.`
75			`*/`
76			`public static DatatypeFactory newInstance()`
77			`throws DatatypeConfigurationException`
78			`{`
79			`try`
80			`{`
81			`// 1. system property`
82			`String className = System.getProperty(DATATYPEFACTORY_PROPERTY);`
83			`if (className != null)`
84			`return (DatatypeFactory) Class.forName(className).newInstance();`
85			`// 2. jaxp.properties property`
86			`File javaHome = new File(System.getProperty("java.home"));`
87			`File javaHomeLib = new File(javaHome, "lib");`
88			`File jaxpProperties = new File(javaHomeLib, "jaxp.properties");`
89			`if (jaxpProperties.exists())`
90			`{`
91			`FileInputStream in = new FileInputStream(jaxpProperties);`
92			`Properties p = new Properties();`
93			`p.load(in);`
94			`in.close();`
95			`className = p.getProperty(DATATYPEFACTORY_PROPERTY);`
96			`if (className != null)`
97			`return (DatatypeFactory) Class.forName(className).newInstance();`
98			`}`
99			`// 3. services`
100			`Iterator<DatatypeFactory> i = ServiceLoader.load(DatatypeFactory.class).iterator();`
101			`if (i.hasNext())`
102			`return i.next();`
103			`// 4. fallback`
104			`Class<?> t = Class.forName(DATATYPEFACTORY_IMPLEMENTATION_CLASS);`
105			`return (DatatypeFactory) t.newInstance();`
106			`}`
107			`catch (Exception e)`
108			`{`
109			`throw new DatatypeConfigurationException(e);`
110			`}`
111			`}`
112
113			`/**`
114			`* Returns a new duration from its string representation.`
115			`* @param lexicalRepresentation the lexical representation of the`
116			`* duration, as specified in XML Schema 1.0 section 3.2.6.1.`
117			`*/`
118			`public abstract Duration newDuration(String lexicalRepresentation);`
119
120			`/**`
121			`* Returns a new duration.`
122			`* @param durationInMilliSeconds the duration in milliseconds`
123			`*/`
124			`public abstract Duration newDuration(long durationInMilliSeconds);`
125
126			`/**`
127			`* Returns a new duration by specifying the individual components.`
128			`* @param isPositive whether the duration is positive`
129			`* @param years the number of years`
130			`* @param months the number of months`
131			`* @param days the number of days`
132			`* @param hours the number of hours`
133			`* @param minutes th number of minutes`
134			`* @param seconds the number of seconds`
135			`*/`
136			`public abstract Duration newDuration(boolean isPositive,`
137			`BigInteger years,`
138			`BigInteger months,`
139			`BigInteger days,`
140			`BigInteger hours,`
141			`BigInteger minutes,`
142			`BigDecimal seconds);`
143
144			`/**`
145			`* Returns a new duration by specifying the individual components.`
146			`* @param isPositive whether the duration is positive`
147			`* @param years the number of years`
148			`* @param months the number of months`
149			`* @param days the number of days`
150			`* @param hours the number of hours`
151			`* @param minutes th number of minutes`
152			`* @param seconds the number of seconds`
153			`*/`
154			`public Duration newDuration(boolean isPositive,`
155			`int years,`
156			`int months,`
157			`int days,`
158			`int hours,`
159			`int minutes,`
160			`int seconds)`
161			`{`
162			`return newDuration(isPositive,`
163			`BigInteger.valueOf((long) years),`
164			`BigInteger.valueOf((long) months),`
165			`BigInteger.valueOf((long) days),`
166			`BigInteger.valueOf((long) hours),`
167			`BigInteger.valueOf((long) minutes),`
168			`BigDecimal.valueOf((long) seconds));`
169			`}`
170
171			`/**`
172			`* Returns a new dayTimeDuration from its string representation.`
173			`* @param lexicalRepresentation the lexical representation of the`
174			`* duration, as specified in XML Schema 1.0 section 3.2.6.1.`
175			`*/`
176			`public Duration newDurationDayTime(String lexicalRepresentation)`
177			`{`
178			`return newDuration(lexicalRepresentation);`
179			`}`
180
181			`/**`
182			`* Returns a new dayTimeDuration.`
183			`* @param durationInMilliseconds the duration in milliseconds`
184			`*/`
185			`public Duration newDurationDayTime(long durationInMilliseconds)`
186			`{`
187			`// TODO xmlSchemaType`
188			`return newDuration(durationInMilliseconds);`
189			`}`
190
191			`/**`
192			`* Returns a new dayTimeDuration by specifying the individual components.`
193			`* @param isPositive whether the duration is positive`
194			`* @param days the number of days`
195			`* @param hours the number of hours`
196			`* @param minutes th number of minutes`
197			`* @param seconds the number of seconds`
198			`*/`
199			`public Duration newDurationDayTime(boolean isPositive,`
200			`BigInteger days,`
201			`BigInteger hours,`
202			`BigInteger minutes,`
203			`BigInteger seconds)`
204			`{`
205			`return newDuration(isPositive,`
206			`null,`
207			`null,`
208			`days,`
209			`hours,`
210			`minutes,`
211			`new BigDecimal(seconds));`
212			`}`
213
214			`/**`
215			`* Returns a new dayTimeDuration by specifying the individual components.`
216			`* @param isPositive whether the duration is positive`
217			`* @param days the number of days`
218			`* @param hours the number of hours`
219			`* @param minutes th number of minutes`
220			`* @param seconds the number of seconds`
221			`*/`
222			`public Duration newDurationDayTime(boolean isPositive,`
223			`int days,`
224			`int hours,`
225			`int minutes,`
226			`int seconds)`
227			`{`
228			`return newDuration(isPositive,`
229			`null,`
230			`null,`
231			`BigInteger.valueOf((long) days),`
232			`BigInteger.valueOf((long) hours),`
233			`BigInteger.valueOf((long) minutes),`
234			`BigDecimal.valueOf((long) seconds));`
235			`}`
236
237			`/**`
238			`* Returns a new yearMonthDuration from its string representation.`
239			`* @param lexicalRepresentation the lexical representation of the`
240			`* duration, as specified in XML Schema 1.0 section 3.2.6.1.`
241			`*/`
242			`public Duration newDurationYearMonth(String lexicalRepresentation)`
243			`{`
244			`return newDuration(lexicalRepresentation);`
245			`}`
246
247			`/**`
248			`* Returns a new yearMonthDuration.`
249			`* @param durationInMilliseconds the duration in milliseconds`
250			`*/`
251			`public Duration newDurationYearMonth(long durationInMilliseconds)`
252			`{`
253			`// TODO xmlSchemaType`
254			`return newDuration(durationInMilliseconds);`
255			`}`
256
257			`/**`
258			`* Returns a new yearMonthDuration by specifying the individual components.`
259			`* @param isPositive whether the duration is positive`
260			`* @param years the number of years`
261			`* @param months the number of months`
262			`*/`
263			`public Duration newDurationYearMonth(boolean isPositive,`
264			`BigInteger years,`
265			`BigInteger months)`
266			`{`
267			`return newDuration(isPositive,`
268			`years,`
269			`months,`
270			`null,`
271			`null,`
272			`null,`
273			`null);`
274			`}`
275
276			`/**`
277			`* Returns a new yearMonthDuration by specifying the individual components.`
278			`* @param isPositive whether the duration is positive`
279			`* @param years the number of years`
280			`* @param months the number of months`
281			`*/`
282			`public Duration newDurationYearMonth(boolean isPositive,`
283			`int years,`
284			`int months)`
285			`{`
286			`return newDuration(isPositive,`
287			`BigInteger.valueOf((long) years),`
288			`BigInteger.valueOf((long) months),`
289			`null,`
290			`null,`
291			`null,`
292			`null);`
293			`}`
294
295			`/**`
296			`* Returns a new XMLGregorianCalendar with no fields initialized.`
297			`*/`
298			`public abstract XMLGregorianCalendar newXMLGregorianCalendar();`
299
300			`/**`
301			`* Returns a new XMLGregorianCalendar from a string representation.`
302			`* @param lexicalRepresentation the lexical representation as specified in`
303			`* XML Schema 1.0 Part 2, section 3.2.[7-14].1.`
304			`*/`
305			`public abstract XMLGregorianCalendar newXMLGregorianCalendar(String lexicalRepresentation);`
306
307			`/**`
308			`* Returns a new XMLGregorianCalendar based on the specified Gregorian`
309			`* calendar.`
310			`*/`
311			`public abstract XMLGregorianCalendar newXMLGregorianCalendar(GregorianCalendar cal);`
312
313			`/**`
314			`* Returns a new XMLGregorianCalendar with the specified components.`
315			`*/`
316			`public abstract XMLGregorianCalendar newXMLGregorianCalendar(BigInteger year,`
317			`int month,`
318			`int day,`
319			`int hour,`
320			`int minute,`
321			`int second,`
322			`BigDecimal fractionalSecond,`
323			`int timezone);`
324
325			`/**`
326			`* Returns a new XMLGregorianCalendar with the specified components.`
327			`*/`
328			`public XMLGregorianCalendar newXMLGregorianCalendar(int year,`
329			`int month,`
330			`int day,`
331			`int hour,`
332			`int minute,`
333			`int second,`
334			`int millisecond,`
335			`int timezone)`
336			`{`
337			`return newXMLGregorianCalendar(BigInteger.valueOf((long) year),`
338			`month,`
339			`day,`
340			`hour,`
341			`minute,`
342			`second,`
343			`new BigDecimal(((double) millisecond) / 1000.0),`
344			`timezone);`
345			`}`
346
347			`/**`
348			`* Returns a new XMLGregorianCalendar with the specified components.`
349			`*/`
350			`public XMLGregorianCalendar newXMLGregorianCalendarDate(int year,`
351			`int month,`
352			`int day,`
353			`int timezone)`
354			`{`
355			`return newXMLGregorianCalendar(BigInteger.valueOf((long) year),`
356			`month,`
357			`day,`
358			`DatatypeConstants.FIELD_UNDEFINED,`
359			`DatatypeConstants.FIELD_UNDEFINED,`
360			`DatatypeConstants.FIELD_UNDEFINED,`
361			`null,`
362			`timezone);`
363			`}`
364
365			`/**`
366			`* Returns a new XMLGregorianCalendar with the specified components.`
367			`*/`
368			`public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,`
369			`int minutes,`
370			`int seconds,`
371			`int timezone)`
372			`{`
373			`return newXMLGregorianCalendar(null,`
374			`DatatypeConstants.FIELD_UNDEFINED,`
375			`DatatypeConstants.FIELD_UNDEFINED,`
376			`hours,`
377			`minutes,`
378			`seconds,`
379			`null,`
380			`timezone);`
381			`}`
382
383			`/**`
384			`* Returns a new XMLGregorianCalendar with the specified components.`
385			`*/`
386			`public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,`
387			`int minutes,`
388			`int seconds,`
389			`BigDecimal fractionalSecond,`
390			`int timezone)`
391			`{`
392			`return newXMLGregorianCalendar(null,`
393			`DatatypeConstants.FIELD_UNDEFINED,`
394			`DatatypeConstants.FIELD_UNDEFINED,`
395			`hours,`
396			`minutes,`
397			`seconds,`
398			`fractionalSecond,`
399			`timezone);`
400			`}`
401
402			`/**`
403			`* Returns a new XMLGregorianCalendar with the specified components.`
404			`*/`
405			`public XMLGregorianCalendar newXMLGregorianCalendarTime(int hours,`
406			`int minutes,`
407			`int seconds,`
408			`int milliseconds,`
409			`int timezone)`
410			`{`
411			`return newXMLGregorianCalendar(null,`
412			`DatatypeConstants.FIELD_UNDEFINED,`
413			`DatatypeConstants.FIELD_UNDEFINED,`
414			`hours,`
415			`minutes,`
416			`seconds,`
417			`new BigDecimal(((double) milliseconds) / 1000.0),`
418			`timezone);`
419			`}`
420
421			`}`