1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
font color='#880088'> package javax.xml.stream; import javax.xml.transform.Result; /** * Defines an abstract implementation of a factory for * getting XMLEventWriters and XMLStreamWriters. * * The following table defines the standard properties of this specification. * Each property varies in the level of support required by each implementation. * The level of support required is described in the 'Required' column. * * <table border="2" rules="all" cellpadding="4"> * <thead> * <tr> * <th align="center" colspan="2"> * Configuration parameters * </th> * </tr> * </thead> * <tbody> * <tr> * <th>Property Name</th> * <th>Behavior</th> * <th>Return type</th> * <th>Default Value</th> * <th>Required</th> * </tr> * <tr><td>javax.xml.stream.isRepairingNamespaces</td><td>defaults prefixes on the output side</td><td>Boolean</td><td>False</td><td>Yes</td></tr> * </tbody> * </table> * * <p>The following paragraphs describe the namespace and prefix repair algorithm:</p> * * <p>The property can be set with the following code line: * <code>setProperty("javax.xml.stream.isRepairingNamespaces",new Boolean(true|false));</code></p> * * <p>This property specifies that the writer default namespace prefix declarations. * The default value is false. </p> * * <p>If a writer isRepairingNamespaces it will create a namespace declaration * on the current StartElement for * any attribute that does not * currently have a namespace declaration in scope. If the StartElement * has a uri but no prefix specified a prefix will be assigned, if the prefix * has not been declared in a parent of the current StartElement it will be declared * on the current StartElement. If the defaultNamespace is bound and in scope * and the default namespace matches the URI of the attribute or StartElement * QName no prefix will be assigned.</p> * * <p>If an element or attribute name has a prefix, but is not * bound to any namespace URI, then the prefix will be removed * during serialization.</p> * * <p>If element and/or attribute names in the same start or * empty-element tag are bound to different namespace URIs and * are using the same prefix then the element or the first * occurring attribute retains the original prefix and the * following attributes have their prefixes replaced with a * new prefix that is bound to the namespace URIs of those * attributes. </p> * * <p>If an element or attribute name uses a prefix that is * bound to a different URI than that inherited from the * namespace context of the parent of that element and there * is no namespace declaration in the context of the current * element then such a namespace declaration is added. </p> * * <p>If an element or attribute name is bound to a prefix and * there is a namespace declaration that binds that prefix * to a different URI then that namespace declaration is * either removed if the correct mapping is inherited from * the parent context of that element, or changed to the * namespace URI of the element or attribute using that prefix.</p> * * @version 1.0 * @author Copyright (c) 2003 by BEA Systems. All Rights Reserved. * @see XMLInputFactory * @see XMLEventWriter * @see XMLStreamWriter * @since 1.6 */ public abstract class XMLOutputFactory { /** * Property used to set prefix defaulting on the output side */ public static final String IS_REPAIRING_NAMESPACES= "javax.xml.stream.isRepairingNamespaces"; protected XMLOutputFactory(){} /** * Create a new instance of the factory. * @throws FactoryConfigurationError if an instance of this factory cannot be loaded */ public static XMLOutputFactory newInstance() throws FactoryConfigurationError { return (XMLOutputFactory) FactoryFinder.find("javax.xml.stream.XMLOutputFactory", "com.sun.xml.internal.stream.XMLOutputFactoryImpl"); } /** * Create a new instance of the factory. * * @param factoryId Name of the factory to find, same as * a property name * @param classLoader classLoader to use * @return the factory implementation * @throws FactoryConfigurationError if an instance of this factory cannot be loaded */ public static XMLInputFactory newInstance(String factoryId, ClassLoader classLoader) throws FactoryConfigurationError { try { //do not fallback if given classloader can't find the class, throw exception return (XMLInputFactory) FactoryFinder.newInstance(factoryId, classLoader, false); } catch (FactoryFinder.ConfigurationError e) { throw new FactoryConfigurationError(e.getException(), e.getMessage()); } } /** * Create a new XMLStreamWriter that writes to a writer * @param stream the writer to write to * @throws XMLStreamException */ public abstract XMLStreamWriter createXMLStreamWriter(java.io.Writer stream) throws XMLStreamException; /** * Create a new XMLStreamWriter that writes to a stream * @param stream the stream to write to * @throws XMLStreamException */ public abstract XMLStreamWriter createXMLStreamWriter(java.io.OutputStream stream) throws XMLStreamException; /** * Create a new XMLStreamWriter that writes to a stream * @param stream the stream to write to * @param encoding the encoding to use * @throws XMLStreamException */ public abstract XMLStreamWriter createXMLStreamWriter(java.io.OutputStream stream, String encoding) throws XMLStreamException; /** * Create a new XMLStreamWriter that writes to a JAXP result. This method is optional. * @param result the result to write to * @throws UnsupportedOperationException if this method is not * supported by this XMLOutputFactory * @throws XMLStreamException */ public abstract XMLStreamWriter createXMLStreamWriter(Result result) throws XMLStreamException; /** * Create a new XMLEventWriter that writes to a JAXP result. This method is optional. * @param result the result to write to * @throws UnsupportedOperationException if this method is not * supported by this XMLOutputFactory * @throws XMLStreamException */ public abstract XMLEventWriter createXMLEventWriter(Result result) throws XMLStreamException; /** * Create a new XMLEventWriter that writes to a stream * @param stream the stream to write to * @throws XMLStreamException */ public abstract XMLEventWriter createXMLEventWriter(java.io.OutputStream stream) throws XMLStreamException; /** * Create a new XMLEventWriter that writes to a stream * @param stream the stream to write to * @param encoding the encoding to use * @throws XMLStreamException */ public abstract XMLEventWriter createXMLEventWriter(java.io.OutputStream stream, String encoding) throws XMLStreamException; /** * Create a new XMLEventWriter that writes to a writer * @param stream the stream to write to * @throws XMLStreamException */ public abstract XMLEventWriter createXMLEventWriter(java.io.Writer stream) throws XMLStreamException; /** * Allows the user to set specific features/properties on the underlying implementation. * @param name The name of the property * @param value The value of the property * @throws java.lang.IllegalArgumentException if the property is not supported */ public abstract void setProperty(java.lang.String name, Object value) throws IllegalArgumentException; /** * Get a feature/property on the underlying implementation * @param name The name of the property * @return The value of the property * @throws java.lang.IllegalArgumentException if the property is not supported */ public abstract Object getProperty(java.lang.String name) throws IllegalArgumentException; /** * Query the set of properties that this factory supports. * * @param name The name of the property (may not be null) * @return true if the property is supported and false otherwise */ public abstract boolean isPropertySupported(String name); }