libjava/javax/xml/parsers/DocumentBuilderFactory.java

   1 /* DocumentBuilderFactory.java --
   2    Copyright (C) 2004, 2005  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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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.parsers;
  39
  40 import java.io.BufferedReader;
  41 import java.io.File;
  42 import java.io.FileInputStream;
  43 import java.io.InputStream;
  44 import java.io.InputStreamReader;
  45 import java.io.IOException;
  46 import java.util.Properties;
  47 import javax.xml.validation.Schema;
  48
  49 /**
  50  * Factory for obtaining document builders.
  51  * Instances of this class are <em>not</em> guaranteed to be thread safe.
  52  *
  53  * @author (a href='mailto:dog@gnu.org'>Chris Burdess</a)
  54  */
  55 public abstract class DocumentBuilderFactory
  56 {
  57
  58   private boolean namespaceAware;
  59   private boolean validating;
  60   private boolean ignoringElementContentWhitespace;
  61   private boolean expandEntityReferences = true;
  62   private boolean ignoringComments;
  63   private boolean coalescing;
  64   private Schema schema;
  65   private boolean xIncludeAware;
  66
  67   protected DocumentBuilderFactory()
  68   {
  69   }
  70
  71   /**
  72    * Creates a new factory instance.
  73    * The implementation class to load is the first found in the following
  74    * locations:
  75    * <ol>
  76    * <li>the <code>javax.xml.parsers.DocumentBuilderFactory</code> system
  77    * property</li>
  78    * <li>the above named property value in the
  79    * <code><i>$JAVA_HOME</i>/lib/jaxp.properties</code> file</li>
  80    * <li>the class name specified in the
  81    * <code>META-INF/services/javax.xml.parsers.DocumentBuilderFactory</code>
  82    * system resource</li>
  83    * <li>the default factory class</li>
  84    * </ol>
  85    */
  86   public static DocumentBuilderFactory newInstance()
  87   {
  88     ClassLoader loader = Thread.currentThread().getContextClassLoader();
  89     if (loader == null)
  90       {
  91         loader = DocumentBuilderFactory.class.getClassLoader();
  92       }
  93     String className = null;
  94     int count = 0;
  95     do
  96       {
  97         className = getFactoryClassName(loader, count++);
  98         if (className != null)
  99           {
 100             try
 101               {
 102                 Class t = (loader != null) ? loader.loadClass(className) :
 103                   Class.forName(className);
 104                 return (DocumentBuilderFactory) t.newInstance();
 105               }
 106             catch (ClassNotFoundException e)
 107               {
 108                 className = null;
 109               }
 110             catch (Exception e)
 111               {
 112                 throw new FactoryConfigurationError(e,
 113                     "error instantiating class " + className);
 114               }
 115           }
 116       }
 117     while (className == null && count < 3);
 118     return new gnu.xml.dom.DomDocumentBuilderFactory();
 119   }
 120
 121   private static String getFactoryClassName(ClassLoader loader, int attempt)
 122   {
 123     final String propertyName = "javax.xml.parsers.DocumentBuilderFactory";
 124     switch (attempt)
 125       {
 126         case 0:
 127           return System.getProperty(propertyName);
 128         case 1:
 129           try
 130             {
 131               File file = new File(System.getProperty("java.home"));
 132               file = new File(file, "lib");
 133               file = new File(file, "jaxp.properties");
 134               InputStream in = new FileInputStream(file);
 135               Properties props = new Properties();
 136               props.load(in);
 137               in.close();
 138               return props.getProperty(propertyName);
 139             }
 140           catch (IOException e)
 141             {
 142               return null;
 143             }
 144         case 2:
 145           try
 146             {
 147               String serviceKey = "/META-INF/services/" + propertyName;
 148               InputStream in = (loader != null) ?
 149                 loader.getResourceAsStream(serviceKey) :
 150                 DocumentBuilderFactory.class.getResourceAsStream(serviceKey);
 151               if (in != null)
 152                 {
 153                   BufferedReader r =
 154                     new BufferedReader(new InputStreamReader(in));
 155                   String ret = r.readLine();
 156                   r.close();
 157                   return ret;
 158                 }
 159             }
 160           catch (IOException e)
 161             {
 162             }
 163           return null;
 164         default:
 165           return null;
 166       }
 167   }
 168
 169   /**
 170    * Creates a new document builder instance using the currently specified
 171    * factory configuration.
 172    * @exception ParserConfigurationException if the specified configuration
 173    * is not supported
 174    */
 175   public abstract DocumentBuilder newDocumentBuilder()
 176     throws ParserConfigurationException;
 177
 178   /**
 179    * Sets whether document builders obtained from this factory will be XML
 180    * Namespace aware.
 181    */
 182   public void setNamespaceAware(boolean awareness)
 183   {
 184     namespaceAware = awareness;
 185   }
 186
 187   /**
 188    * Sets whether document builders obtained from this factory will validate
 189    * their input.
 190    */
 191   public void setValidating(boolean validating)
 192   {
 193     this.validating = validating;
 194   }
 195
 196   /**
 197    * Sets whether document builders obtained from this factory will
 198    * eliminate whitespace within elements that have an element-only content
 199    * model.
 200    */
 201   public void setIgnoringElementContentWhitespace(boolean whitespace)
 202   {
 203     ignoringElementContentWhitespace = whitespace;
 204   }
 205
 206   /**
 207    * Sets whether document builders obtained from this factory will expand
 208    * entity reference nodes.
 209    */
 210   public void setExpandEntityReferences(boolean expandEntityRef)
 211   {
 212     expandEntityReferences = expandEntityRef;
 213   }
 214
 215   /**
 216    * Sets whether document builders obtained from this factory will discard
 217    * comment nodes.
 218    */
 219   public void setIgnoringComments(boolean ignoreComments)
 220   {
 221     ignoringComments = ignoreComments;
 222   }
 223
 224   /**
 225    * Sets whether document builders obtained from this factory will convert
 226    * CDATA sections to text nodes and normalize adjacent text nodes into a
 227    * single text node.
 228    */
 229   public void setCoalescing(boolean coalescing)
 230   {
 231     this.coalescing = coalescing;
 232   }
 233
 234   /**
 235    * Indicates whether document builders obtained from this factory will be
 236    * XML Namespace aware.
 237    */
 238   public boolean isNamespaceAware()
 239   {
 240     return namespaceAware;
 241   }
 242
 243   /**
 244    * Indicates whether document builders obtained from this factory will
 245    * validate their input.
 246    */
 247   public boolean isValidating()
 248   {
 249     return validating;
 250   }
 251
 252   /**
 253    * Indicates whether document builders obtained from this factory will
 254    * eliminate whitespace within elements that have an element-only content
 255    * model.
 256    */
 257   public boolean isIgnoringElementContentWhitespace()
 258   {
 259     return ignoringElementContentWhitespace;
 260   }
 261
 262   /**
 263    * Indicates whether document builders obtained from this factory will
 264    * expand entity reference nodes.
 265    */
 266   public boolean isExpandEntityReferences()
 267   {
 268     return expandEntityReferences;
 269   }
 270
 271   /**
 272    * Indicates whether document builders obtained from this factory will
 273    * discard comment nodes.
 274    */
 275   public boolean isIgnoringComments()
 276   {
 277     return ignoringComments;
 278   }
 279
 280   /**
 281    * Indicates whether document builders obtained from this factory will
 282    * convert CDATA sections to text nodes and normalize adjacent text nodes
 283    * into a single text node.
 284    */
 285   public boolean isCoalescing()
 286   {
 287     return coalescing;
 288   }
 289
 290   /**
 291    * Set the named attribute on the underlying implementation.
 292    * @param name the name of the attribute
 293    * @param value the new value
 294    * @exception IllegalArgumentException if the attribute is not recognized
 295    */
 296   public abstract void setAttribute(String name, Object value)
 297     throws IllegalArgumentException;
 298
 299   /**
 300    * Retrieves the named attribute value from the underlying implementation.
 301    * @param name the name of the attribute
 302    * @exception IllegalArgumentException if the attribute is not recognized
 303    */
 304   public abstract Object getAttribute(String name)
 305     throws IllegalArgumentException;
 306
 307   // -- JAXP 1.3 methods --
 308
 309   /**
 310    * Returns the schema.
 311    * @see #setSchema
 312    */
 313   public Schema getSchema()
 314   {
 315     return schema;
 316   }
 317
 318   /**
 319    * Sets the schema.
 320    * @see #getSchema
 321    */
 322   public void setSchema(Schema schema)
 323   {
 324     this.schema = schema;
 325   }
 326
 327   /**
 328    * Indicates whether parsers obtained from this factory will be XInclude
 329    * aware.
 330    * @since 1.3
 331    */
 332   public boolean isXIncludeAware()
 333   {
 334     return xIncludeAware;
 335   }
 336
 337   /**
 338    * Sets whether parsers obtained from this factory will be XInclude aware.
 339    * @since 1.3
 340    */
 341   public void setXIncludeAware(boolean state)
 342   {
 343     xIncludeAware = state;
 344   }
 345
 346 }