event = staxEventReader.peek(); if( !event.isStartDocument() && !event.isStartElement() ) throw new IllegalStateException(); event = staxEventReader.nextEvent(); } while( !event.isStartElement() ); handleStartDocument(event.asStartElement().getNamespaceContext()); event=staxEventReader.nextEvent(); throw new XMLStreamException(e);
@Override public final void writeCollection(Class<?> elementType, Collection<?> t, MediaType mediaType, Charset c, Marshaller m, OutputStream entityStream) throws JAXBException, IOException { final OutputStreamWriter osw = new OutputStreamWriter(entityStream, c); JettisonConfig origJsonConfig = JettisonConfig.DEFAULT; if (m instanceof JettisonConfigured) { origJsonConfig = ((JettisonConfigured) m).getJSONConfiguration(); } final JettisonConfig unwrappingJsonConfig = JettisonConfig.createJSONConfiguration(origJsonConfig); final XMLStreamWriter jxsw = Stax2JettisonFactory.createWriter(osw, unwrappingJsonConfig); final String invisibleRootName = getRootElementName(elementType); try { jxsw.writeStartDocument(); jxsw.writeStartElement(invisibleRootName); for (Object o : t) { m.marshal(o, jxsw); } jxsw.writeEndElement(); jxsw.writeEndDocument(); jxsw.flush(); } catch (XMLStreamException ex) { Logger.getLogger(JettisonListElementProvider.class.getName()).log(Level.SEVERE, null, ex); throw new JAXBException(ex.getMessage(), ex); } }
static ConfigXMLParseException from(final XMLStreamException exception) { if (exception instanceof ConfigXMLParseException) return (ConfigXMLParseException) exception; final StackTraceElement[] stackTrace = exception.getStackTrace(); final Throwable cause = exception.getCause(); final ConfigXMLParseException parseException; if (cause != null) { parseException = new ConfigXMLParseException(clean(exception.getMessage()), exception.getLocation(), cause); } else { parseException = new ConfigXMLParseException(clean(exception.getMessage()), exception.getLocation()); } parseException.setStackTrace(stackTrace); return parseException; }
private void parse() throws SAXException { try { parseInternal(); } catch (XMLStreamException ex) { Locator locator = null; if (ex.getLocation() != null) { locator = new StaxLocator(ex.getLocation()); } SAXParseException saxException = new SAXParseException(ex.getMessage(), locator, ex); if (getErrorHandler() != null) { getErrorHandler().fatalError(saxException); } else { throw saxException; } } }
XMLStreamWriter writer = factory.createXMLStreamWriter(stringWriter); while ( reader.hasNext() ) { int event = reader.next(); if (reader.getLocalName().equals("ins")) writer.writeEndElement(); writer.writeEndElement(); memory = null; if (reader.getNamespaceURI() == null ) { writer.writeStartElement(reader.getLocalName()); throw new XMLStreamException("Issue at element: " + reader.getLocalName() + "\n",e);
public void add(XMLEvent event) throws XMLStreamException { if (event.isStartDocument()) { streamWriter.writeStartDocument(); } else if (event.isStartElement()) { StartElement element = event.asStartElement(); QName elQName = element.getName(); if (elQName.getPrefix().length() > 0 && elQName.getNamespaceURI().length() > 0) streamWriter.writeStartElement(elQName.getPrefix(), elQName streamWriter.writeStartElement(elQName.getNamespaceURI(), Iterator namespaces = element.getNamespaces(); while (namespaces.hasNext()) { Namespace ns = (Namespace) namespaces.next(); String prefix = ns.getPrefix(); String nsURI = ns.getNamespaceURI(); Iterator attris = element.getAttributes(); while (attris.hasNext()) { Attribute attr = (Attribute) attris.next(); streamWriter.writeCharacters(chars.getData()); throw new XMLStreamException("Unsupported event type: " + event);
@SuppressWarnings("unchecked") private void handleEndElement(EndElement event) throws XMLStreamException { QName qName = event.getName(); try { String prefix = qName.getPrefix(); String rawname; if (prefix == null || prefix.length() == 0) { rawname = qName.getLocalPart(); } else { rawname = prefix + ':' + qName.getLocalPart(); } this.filter.endElement(qName.getNamespaceURI(), qName.getLocalPart(), rawname); for (Iterator<Namespace> i = event.getNamespaces(); i.hasNext(); ) { String nsprefix = i.next().getPrefix(); if (nsprefix == null) { // true for default namespace nsprefix = ""; } this.filter.endPrefixMapping(nsprefix); } } catch (SAXException e) { throw new XMLStreamException(e); } }
@SuppressWarnings("unchecked") private void handleStartElement(StartElement event) throws XMLStreamException { try { for (Iterator<Namespace> i = event.getNamespaces(); i.hasNext(); ) { String prefix = i.next().getPrefix(); if (prefix == null) { // true for default namespace prefix = ""; } this.filter.startPrefixMapping(prefix, event.getNamespaceURI(prefix)); } QName qName = event.getName(); String prefix = qName.getPrefix(); String rawname; if (prefix == null || prefix.length() == 0) { rawname = qName.getLocalPart(); } else { rawname = prefix + ':' + qName.getLocalPart(); } Attributes saxAttrs = getAttributes(event); this.filter.startElement(qName.getNamespaceURI(), qName.getLocalPart(), rawname, saxAttrs); } catch (SAXException e) { throw new XMLStreamException(e); } }
private static NodeLibrary load(String libraryName, File file, Reader r, NodeRepository nodeRepository) throws XMLStreamException { XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance(); XMLStreamReader reader = xmlInputFactory.createXMLStreamReader(r); NodeLibrary nodeLibrary = null; while (reader.hasNext()) { int eventType = reader.next(); if (eventType == XMLStreamConstants.START_ELEMENT) { String tagName = reader.getLocalName(); if (tagName.equals("ndbx")) { String formatVersion = reader.getAttributeValue(null, "formatVersion"); if (formatVersion != null && !CURRENT_FORMAT_VERSION.equals(formatVersion)) { throw new OutdatedLibraryException(file, "File uses version " + formatVersion + ", current version is " + CURRENT_FORMAT_VERSION + "."); } String uuidString = reader.getAttributeValue(null, "uuid"); UUID uuid = (uuidString == null) ? UUID.randomUUID() : UUID.fromString(uuidString); nodeLibrary = parseNDBX(libraryName, file, reader, nodeRepository, uuid); } else { throw new XMLStreamException("Only tag ndbx allowed, not " + tagName, reader.getLocation()); } } } return nodeLibrary; }
GCModel model = new GCModel(); try { XMLInputFactory factory = XMLInputFactory.newInstance(); XMLEventReader eventReader = factory.createXMLEventReader(in); GCEvent currentGcEvent = null; String eventNameStart = null; while (eventReader.hasNext()) { try { XMLEvent event = eventReader.nextEvent(); if (event.isStartElement()) { StartElement startElement = event.asStartElement(); switch (startElement.getName().getLocalPart()) { case VERBOSEGC: handleVerboseGC(startElement); if (getLogger().isLoggable(Level.WARNING)) getLogger().warning("line " + in.getLineNumber() + ": " + e.toString()); if (getLogger().isLoggable(Level.FINE)) getLogger().log(Level.FINE, "line " + in.getLineNumber() + ": " + e.getMessage(), e);
public void writeTo(javax.xml.stream.XMLStreamWriter streamWriter) throws XMLStreamException { try { // If writing to Zephyr, get output stream and use JAXB UTF-8 writer if (streamWriter instanceof Map) { OutputStream os = (OutputStream) ((Map) streamWriter).get("sjsxp-outputstream"); if (os != null) { streamWriter.writeCharacters(""); // Force completion of open elems getMarshaller().marshal(signature, os); return; } } getMarshaller().marshal(signature,streamWriter); } catch (JAXBException e) { throw new XMLStreamException(e); } }
errors.add("bad conf file: " + e.getMessage()); int line = element.getLocation().getLineNumber(); if (!element.getName().equals(new QName("property"))) { errors.add(String.format("Line %d: element not <property>", line)); continue; List<XMLEvent> events = node.getXMLEventsForQName(new QName("name")); if (events == null) { errors.add(String.format("Line %d: <property> has no <name>", line)); String v = null; for (XMLEvent event : events) { if (event.isAttribute()) { v = ((Attribute) event).getValue(); } else { Characters c = node.getElement(event.asStartElement()); if (c != null) { v = c.getData(); duplicatedProperties.put(v, lines); lines.add(node.getStartElement().getLocation().getLineNumber());
public static PlanNode fromXml(String planString) throws XMLStreamException { XMLInputFactory inputFactory = XMLType.getXmlInputFactory(); XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(planString)); while (reader.hasNext()&& (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { String element = reader.getLocalName(); if (element.equals("node")) { //$NON-NLS-1$ Properties props = getAttributes(reader); PlanNode planNode = new PlanNode(props.getProperty("name"));//$NON-NLS-1$ planNode.setParent(null); buildNode(reader, planNode); return planNode; } throw new XMLStreamException(JDBCPlugin.Util.gs("unexpected_element", reader.getName(), "node"),reader.getLocation());//$NON-NLS-1$ //$NON-NLS-2$ } return null; }
public static List<Dependency> readDependencies(Reader pomReader){ List<Dependency> dependencies = new ArrayList<>(); XMLInputFactory factory = XMLInputFactory.newInstance(); try { XMLStreamReader streamReader = factory.createXMLStreamReader(pomReader); while(streamReader.hasNext()){ streamReader.next(); if(streamReader.getEventType() == XMLStreamReader.START_ELEMENT){ String elementName = streamReader.getLocalName(); if(elementName.equals("dependency")){ Dependency dependency = parseDependency(streamReader); dependencies.add(dependency); } } } } catch (XMLStreamException e) { e.printStackTrace(); } return dependencies; }
private void scanPage() throws XMLStreamException { if (!eventIsStartElement(PAGE_TAG)) { throw new XMLStreamException("Parse error."); } while (reader.hasNext()) { event = reader.nextEvent(); if (event.getEventType()==XMLStreamConstants.START_ELEMENT) { if (ROW_TAG.equals(event.asStartElement().getName())) { scanRow(); } } else if (eventIsEndElement(PAGE_TAG)) { break; } } }
public QName createQName(String rootName, Node node) throws XMLStreamException { int idx = rootName.indexOf(':'); if (idx != -1) { String prefix = rootName.substring(0, idx); String local = rootName.substring(idx+1); String uri = (String) node.getNamespaceURI(prefix); if (uri == null) { throw new XMLStreamException("Invalid prefix " + prefix + " on element " + rootName); } return new QName(uri, local, prefix); } String uri = (String) node.getNamespaceURI(""); if (uri != null) { return new QName(uri, rootName); } return new QName(rootName); } }
XMLEvent event = eventReader.peek(); if (event.isStartElement()) { StartElement startTag = eventReader.nextEvent().asStartElement(); Element elem = createElement(startTag); if (!eventReader.hasNext()) { String msg = "Unexpected end of stream while reading" + " element content"; throw new XMLStreamException(msg); XMLEvent nextEvent = eventReader.peek(); if (nextEvent.isEndElement()) { EndElement endElem = eventReader.nextEvent().asEndElement(); if (!endElem.getName().equals(startTag.getName())) { throw new XMLStreamException("Expected " + startTag.getName() + " end-tag, but found" + endElem.getName()); throw new XMLStreamException("Expected Element event, found: " + event);
nextKey = node.getName().getLocalPart(); if (!"".equals(node.getName().getNamespaceURI())) { nextKey = this.convention.getPrefix(node.getName().getNamespaceURI()) + this.getConvention().getNamespaceSeparator() + nextKey; throw new XMLStreamException(e);
try { xw = XMLOutputFactory.newInstance().createXMLStreamWriter(sw); xw.writeStartDocument(Consts.UTF_8.name(), "1.0"); xw.writeStartElement("xml"); for (String key : obj.keySet()) { if (StringUtil.isBlank(obj.getString(key))) { continue; xw.writeStartElement(key); xw.writeCData(obj.getString(key)); xw.writeEndElement(); xw.writeEndDocument(); } catch (XMLStreamException e) { e.printStackTrace(); } finally { if (xw != null) {
XMLInputFactory xmlFactory = XMLInputFactory.newInstance(); List<TercCode> tercCodeList = new ArrayList<TercCode>(); try { XMLStreamReader xmlReader = xmlFactory.createXMLStreamReader(fname, stream); while (xmlReader.hasNext()) { // returns the event type int eventType = xmlReader.next(); // returns event type for reference if (xmlReader.getEventType() == XMLStreamConstants.START_ELEMENT){ System.out.println(xmlReader.getName().getLocalPart()); } } catch (XMLStreamException e) { e.printStackTrace(); }