libjava/classpath/javax/xml/datatype/DatatypeFactory.java

   1 /* 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 }