/** * Bind the given namespace as default namespace. * @param namespaceUri the namespace uri */ public void bindDefaultNamespaceUri(String namespaceUri) { bindNamespaceUri(XMLConstants.DEFAULT_NS_PREFIX, namespaceUri); }
@Override public void writeEmptyElement(String localName) throws XMLStreamException { closeEmptyElementIfNecessary(); writeStartElement(localName); this.emptyElement = true; }
/** * Parse the StAX XML reader passed at construction-time. * <p><b>NOTE:</b>: The given {@code InputSource} is not read, but ignored. * @param ignored is ignored * @throws SAXException a SAX exception, possibly wrapping a {@code XMLStreamException} */ @Override public final void parse(InputSource ignored) throws SAXException { parse(); }
/** * Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLStreamWriter}. * @param streamWriter the StAX stream writer * @return a source wrapping the {@code streamWriter} */ public static Result createCustomStaxResult(XMLStreamWriter streamWriter) { return new StaxResult(streamWriter); }
/** * Create an {@code XMLInputFactory} that this converter will use to create * {@link javax.xml.stream.XMLStreamReader} and {@link javax.xml.stream.XMLEventReader} * objects. * <p>Can be overridden in subclasses, adding further initialization of the factory. * The resulting factory is cached, so this method will only be called once. * @see StaxUtils#createDefensiveInputFactory() */ protected XMLInputFactory createXmlInputFactory() { return StaxUtils.createDefensiveInputFactory(); }
@Override public boolean hasName() { int eventType = getEventType(); return (eventType == XMLStreamConstants.START_ELEMENT || eventType == XMLStreamConstants.END_ELEMENT); }
/** * Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}. * Useful because the StAX {@code XMLInputFactory} allows one to create an * event reader from a stream reader, but not vice-versa. * @return a stream reader that reads from an event reader */ public static XMLStreamReader createEventStreamReader(XMLEventReader eventReader) throws XMLStreamException { return new XMLEventStreamReader(eventReader); }
private void closeEmptyElementIfNecessary() throws XMLStreamException { if (this.emptyElement) { this.emptyElement = false; writeEndElement(); } }
/** * Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLStreamReader}. * @param streamReader the StAX stream reader * @return a source wrapping the {@code streamReader} */ public static Source createCustomStaxSource(XMLStreamReader streamReader) { return new StaxSource(streamReader); }
/** * Try to consume the {@link #START_COMMENT} token. * @see #commentToken(String, String, boolean) */ private int startComment(String line) { return commentToken(line, START_COMMENT, true); }
/** * Create a SAX {@link ContentHandler} that writes to the given StAX {@link XMLStreamWriter}. * @param streamWriter the StAX stream writer * @return a content handler writing to the {@code streamWriter} */ public static ContentHandler createContentHandler(XMLStreamWriter streamWriter) { return new StaxStreamHandler(streamWriter); }
/** * Create a SAX {@link ContentHandler} that writes events to the given StAX {@link XMLEventWriter}. * @param eventWriter the StAX event writer * @return a content handler writing to the {@code eventWriter} */ public static ContentHandler createContentHandler(XMLEventWriter eventWriter) { return new StaxEventHandler(eventWriter); }
/** * Create a {@link XMLEventReader} from the given list of {@link XMLEvent}. * @param events the list of {@link XMLEvent XMLEvents}. * @return an {@code XMLEventReader} that reads from the given events * @since 5.0 */ public static XMLEventReader createXMLEventReader(List<XMLEvent> events) { return new ListBasedXMLEventReader(events); }
@Override public Object[] adaptArguments(Object[] arguments) { for (int i = 0; i < arguments.length; i++) { if (arguments[i] instanceof Attributes) { arguments[i] = new PartialAttributes((Attributes) arguments[i]); } } return arguments; } }
@Override public void writeEmptyElement(String namespaceURI, String localName) throws XMLStreamException { closeEmptyElementIfNecessary(); writeStartElement(namespaceURI, localName); this.emptyElement = true; }
/** * Parse the StAX XML reader passed at construction-time. * <p><b>NOTE:</b>: The given system identifier is not read, but ignored. * @param ignored is ignored * @throws SAXException a SAX exception, possibly wrapping a {@code XMLStreamException} */ @Override public final void parse(String ignored) throws SAXException { parse(); }
/** * Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLEventWriter}. * @param eventWriter the StAX event writer * @return a source wrapping the {@code eventWriter} */ public static Result createCustomStaxResult(XMLEventWriter eventWriter) { return new StaxResult(eventWriter); }
/** * Create an {@link XMLInputFactory} with Spring's defensive setup, * i.e. no support for the resolution of DTDs and external entities. * @return a new defensively initialized input factory instance to use * @since 5.0 */ public static XMLInputFactory createDefensiveInputFactory() { return createDefensiveInputFactory(XMLInputFactory::newInstance); }
@Override public boolean hasText() { int eventType = getEventType(); return (eventType == XMLStreamConstants.SPACE || eventType == XMLStreamConstants.CHARACTERS || eventType == XMLStreamConstants.COMMENT || eventType == XMLStreamConstants.CDATA || eventType == XMLStreamConstants.ENTITY_REFERENCE); }
@Override public void writeEmptyElement(String prefix, String localName, String namespaceURI) throws XMLStreamException { closeEmptyElementIfNecessary(); writeStartElement(prefix, localName, namespaceURI); this.emptyElement = true; }