libjava/javax/xml/parsers/SAXParserFactory.java

   1 /* SAXParserFactory.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 import org.xml.sax.SAXException;
  49 import org.xml.sax.SAXNotRecognizedException;
  50 import org.xml.sax.SAXNotSupportedException;
  51
  52 /**
  53  * Factory for obtaining SAX parsers.
  54  * Instances of this class are <em>not</em> guaranteed to be thread safe.
  55  *
  56  * @author (a href='mailto:dog@gnu.org'>Chris Burdess</a)
  57  */
  58 public abstract class SAXParserFactory
  59 {
  60
  61   private boolean validating;
  62   private boolean namespaceAware;
  63   private Schema schema;
  64   private boolean xIncludeAware;
  65
  66   protected SAXParserFactory()
  67   {
  68   }
  69
  70   /**
  71    * Creates a new factory instance.
  72    * The implementation class to load is the first found in the following
  73    * locations:
  74    * <ol>
  75    * <li>the <code>javax.xml.parsers.SAXParserFactory</code> system
  76    * property</li>
  77    * <li>the above named property value in the
  78    * <code><i>$JAVA_HOME</i>/lib/jaxp.properties</code> file</li>
  79    * <li>the class name specified in the
  80    * <code>META-INF/services/javax.xml.parsers.SAXParserFactory</code>
  81    * system resource</li>
  82    * <li>the default factory class</li>
  83    * </ol>
  84    */
  85   public static SAXParserFactory newInstance()
  86     throws FactoryConfigurationError
  87   {
  88     ClassLoader loader = Thread.currentThread().getContextClassLoader();
  89     if (loader == null)
  90       {
  91         loader = SAXParserFactory.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 (SAXParserFactory) 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.aelfred2.JAXPFactory();
 119   }
 120
 121   private static String getFactoryClassName(ClassLoader loader, int attempt)
 122   {
 123     final String propertyName = "javax.xml.parsers.SAXParserFactory";
 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                 SAXParserFactory.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 parser instance using the currently specified factory
 171    * configuration.
 172    * @exception ParserConfigurationException if the specified configuration
 173    * is not supported
 174    */
 175   public abstract SAXParser newSAXParser()
 176     throws ParserConfigurationException, SAXException;
 177
 178   /**
 179    * Sets whether parsers obtained from this factory will be XML Namespace
 180    * aware.
 181    */
 182   public void setNamespaceAware(boolean awareness)
 183   {
 184     namespaceAware = awareness;
 185   }
 186
 187   /**
 188    * Sets whether parsers obtained from this factory will validate their
 189    * input.
 190    */
 191   public void setValidating(boolean validating)
 192   {
 193     this.validating = validating;
 194   }
 195
 196   /**
 197    * Indicates whether parsers obtained from this factory will be XML
 198    * Namespace aware.
 199    */
 200   public boolean isNamespaceAware()
 201   {
 202     return namespaceAware;
 203   }
 204
 205   /**
 206    * Indicates whether parsers obtained from this factory will validate
 207    * their input.
 208    */
 209   public boolean isValidating()
 210   {
 211     return validating;
 212   }
 213
 214   /**
 215    * Sets the specified feature for SAX2 parsers obtained from this factory.
 216    * @param name the feature name
 217    * @param value the featurevalue
 218    */
 219   public abstract void setFeature(String name, boolean value)
 220     throws ParserConfigurationException, SAXNotRecognizedException,
 221            SAXNotSupportedException;
 222
 223   /**
 224    * Returns the specified feature for SAX2 parsers obtained from this
 225    * factory.
 226    * @param name the feature name
 227    */
 228   public abstract boolean getFeature(String name)
 229     throws ParserConfigurationException, SAXNotRecognizedException,
 230            SAXNotSupportedException;
 231
 232   // -- JAXP 1.3 methods --
 233
 234   /**
 235    * Returns the schema.
 236    * @since 1.3
 237    * @see #setSchema
 238    */
 239   public Schema getSchema()
 240   {
 241     return schema;
 242   }
 243
 244   /**
 245    * Sets the schema.
 246    * @since 1.3
 247    * @see #getSchema
 248    */
 249   public void setSchema(Schema schema)
 250   {
 251     this.schema = schema;
 252   }
 253
 254   /**
 255    * Indicates whether parsers obtained from this factory will be XInclude
 256    * aware.
 257    * @since 1.3
 258    */
 259   public boolean isXIncludeAware()
 260   {
 261     return xIncludeAware;
 262   }
 263
 264   /**
 265    * Sets whether parsers obtained from this factory will be XInclude aware.
 266    * @since 1.3
 267    */
 268   public void setXIncludeAware(boolean state)
 269   {
 270     xIncludeAware = state;
 271   }
 272
 273 }