// first analyzing of XML input, creating hash map for holding backfire redirects public dataSending firstAnalyzing(String fileName) { Map<String, ReverseRedirects> map = new HashMap<String, ReverseRedirects>(); int pages = 0; String filePath = fileName; XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance(); try { XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(new FileInputStream(filePath)); while (xmlEventReader.hasNext()) { XMLEvent xmlEvent = xmlEventReader.nextEvent(); if (xmlEvent.isStartElement()) { StartElement startElement = xmlEvent.asStartElement(); if (startElement.getName().getLocalPart().toLowerCase().equals("page")) { pages++; } else if (startElement.getName().getLocalPart().toLowerCase().equals("title")) { xmlEvent = xmlEventReader.nextEvent(); map.put(xmlEvent.asCharacters().getData(), new ReverseRedirects(true)); } } } } catch (Exception e) { System.out.println("error: " + e); e.printStackTrace(); return null; } dataSending Result = new dataSending(); Result.map = map; Result.pages = pages; return Result; }
private static RSAKeyValueType parseRSAKeyValue(XMLEventReader xmlEventReader) throws ParsingException { StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader); StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.RSA_KEYVALUE); XMLEvent xmlEvent = null; String tag = null; RSAKeyValueType rsaKeyValue = new RSAKeyValueType(); while (xmlEventReader.hasNext()) { xmlEvent = StaxParserUtil.peek(xmlEventReader); if (xmlEvent instanceof EndElement) { tag = StaxParserUtil.getEndElementName((EndElement) xmlEvent); if (tag.equals(WSTrustConstants.XMLDSig.RSA_KEYVALUE)) { xmlEvent = StaxParserUtil.getNextEndElement(xmlEventReader); break; } else throw logger.parserUnknownEndElement(tag); } startElement = (StartElement) xmlEvent; tag = StaxParserUtil.getStartElementName(startElement); if (tag.equals(WSTrustConstants.XMLDSig.MODULUS)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); String text = StaxParserUtil.getElementText(xmlEventReader); rsaKeyValue.setModulus(text.getBytes()); } else if (tag.equals(WSTrustConstants.XMLDSig.EXPONENT)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); String text = StaxParserUtil.getElementText(xmlEventReader); rsaKeyValue.setExponent(text.getBytes()); } else throw logger.parserUnknownTag(tag, startElement.getLocation()); } return rsaKeyValue; }
public static XmlMessage read(InputStream in) { try { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLEventReader eventReader; eventReader = inputFactory.createXMLEventReader(in); String id = null; String value = null; while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); if (event.isStartElement()) { String tag = event.asStartElement().getName().getLocalPart(); if (ID_TAG.equals(tag)) { event = eventReader.nextEvent(); id = event.asCharacters().getData(); continue; } if (VALUE_TAG.equals(tag)) { event = eventReader.nextEvent(); value = event.asCharacters().getData(); continue; } } } return new XmlMessage(id, value); } catch (XMLStreamException e) { throw new IllegalStateException(e); } }
private void skipElement( final StartElement start, final XMLEventReader reader, final XMLEventWriter writer, final boolean excludeStart) throws Exception { if (!excludeStart) { writeEvent(start, writer); } int depth = 1; boolean found = false; while (reader.hasNext() && !found) { final XMLEvent event = reader.nextEvent(); writeEvent(event, writer); if (event.getEventType() == XMLStreamConstants.START_ELEMENT) { depth++; } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT) { depth--; found = depth == 0 && start.getName().equals(event.asEndElement().getName()); } } }
/** @see {@link ParserNamespaceSupport#parse(XMLEventReader)} */ public Object parse(XMLEventReader xmlEventReader) throws ParsingException { // Get the startelement StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader); StaxParserUtil.validate(startElement, RESPONSE); ResponseType response = (ResponseType) parseBaseAttributes(startElement); while (xmlEventReader.hasNext()) { // Let us peek at the next start element startElement = StaxParserUtil.peekNextStartElement(xmlEventReader); if (startElement == null) break; String elementName = StaxParserUtil.getStartElementName(startElement); if (JBossSAMLConstants.ISSUER.get().equals(elementName)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); NameIDType issuer = new NameIDType(); issuer.setValue(StaxParserUtil.getElementText(xmlEventReader)); response.setIssuer(issuer); } else if (JBossSAMLConstants.SIGNATURE.get().equals(elementName)) { Element sig = StaxParserUtil.getDOMElement(xmlEventReader); response.setSignature(sig); } else if (JBossSAMLConstants.ASSERTION.get().equals(elementName)) { SAMLAssertionParser assertionParser = new SAMLAssertionParser(); response.addAssertion( new RTChoiceType((AssertionType) assertionParser.parse(xmlEventReader))); } else if (JBossSAMLConstants.STATUS.get().equals(elementName)) { response.setStatus(parseStatus(xmlEventReader)); } else if (JBossSAMLConstants.ENCRYPTED_ASSERTION.get().equals(elementName)) { Element encryptedAssertion = StaxParserUtil.getDOMElement(xmlEventReader); response.addAssertion(new RTChoiceType(new EncryptedAssertionType(encryptedAssertion))); } else throw logger.parserUnknownTag(elementName, startElement.getLocation()); } return response; }
/** * Parse an {@code AttributeStatementType} * * @param xmlEventReader * @return * @throws ParsingException */ public static AttributeStatementType parseAttributeStatement(XMLEventReader xmlEventReader) throws ParsingException { AttributeStatementType attributeStatementType = new AttributeStatementType(); StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader); String ATTRIBSTATEMT = JBossSAMLConstants.ATTRIBUTE_STATEMENT.get(); StaxParserUtil.validate(startElement, ATTRIBSTATEMT); while (xmlEventReader.hasNext()) { XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader); if (xmlEvent instanceof EndElement) { EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader); StaxParserUtil.validate(endElement, JBossSAMLConstants.ATTRIBUTE_STATEMENT.get()); break; } // Get the next start element startElement = StaxParserUtil.peekNextStartElement(xmlEventReader); String tag = startElement.getName().getLocalPart(); if (JBossSAMLConstants.ATTRIBUTE.get().equals(tag)) { AttributeType attribute = parseAttribute(xmlEventReader); attributeStatementType.addAttribute(new ASTChoiceType(attribute)); } else throw logger.parserUnknownTag(tag, startElement.getLocation()); } return attributeStatementType; }
private static Book readBook(XMLEventReader eventReader) throws XMLStreamException { while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); if (event.isEndElement()) {} } return null; }
public void testNextTagOk() throws XMLStreamException { String XML = "<root>\n" + "<branch> <leaf> </leaf></branch>" + "</root>"; for (int i = 0; i < 4; ++i) { boolean ns = (i & 1) != 0; boolean coal = (i & 2) != 0; XMLEventReader er = getReader(XML, ns, coal); assertTokenType(START_DOCUMENT, er.nextEvent().getEventType()); assertTokenType(START_ELEMENT, er.nextTag().getEventType()); assertTokenType(START_ELEMENT, er.nextTag().getEventType()); /* Ok, let's mix in bit of peeking to ensure reader won't * be confused too badly... */ // This should be space between <branch> and <leaf>... assertTokenType(CHARACTERS, er.peek().getEventType()); // And then the leaf assertTokenType(START_ELEMENT, er.nextTag().getEventType()); assertTokenType(END_ELEMENT, er.nextTag().getEventType()); assertTokenType(END_ELEMENT, er.nextTag().getEventType()); assertTokenType(END_ELEMENT, er.nextTag().getEventType()); assertTokenType(END_DOCUMENT, er.nextEvent().getEventType()); assertFalse(er.hasNext()); } }
public void testSimpleValid() throws XMLStreamException { /* Whether prolog/epilog white space is reported is not defined * by StAX specs, thus, let's not add any */ String XML = "<?xml version='1.0' ?>" + "<!DOCTYPE root [ ]>" + "<root attr='123'><!-- comment -->\n" + "</root>"; for (int i = 0; i < 4; ++i) { boolean ns = (i & 1) != 0; boolean coal = (i & 2) != 0; XMLEventReader er = getReader(XML, ns, coal); assertTokenType(START_DOCUMENT, er.nextEvent().getEventType()); assertTokenType(DTD, er.nextEvent().getEventType()); assertTokenType(START_ELEMENT, er.nextEvent().getEventType()); assertTokenType(COMMENT, er.nextEvent().getEventType()); // for fun, let's just use next() instead of nextEvent() XMLEvent evt = (XMLEvent) er.next(); assertTokenType(CHARACTERS, evt.getEventType()); assertTokenType(END_ELEMENT, er.nextEvent().getEventType()); assertTokenType(END_DOCUMENT, er.nextEvent().getEventType()); assertFalse(er.hasNext()); er.close(); } }
public XMLElement getXmlElement(final StartElement start, final XMLEventReader reader) throws Exception { final XMLElement res = new XMLElement(); res.setStart(start); final Charset encoding = Charset.forName(org.apache.olingo.commons.api.Constants.UTF8); final ByteArrayOutputStream content = new ByteArrayOutputStream(); final OutputStreamWriter writer = new OutputStreamWriter(content, encoding); int depth = 1; while (reader.hasNext() && depth > 0) { final XMLEvent event = reader.nextEvent(); if (event.getEventType() == XMLStreamConstants.START_ELEMENT) { depth++; } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT) { depth--; } if (depth == 0) { res.setEnd(event.asEndElement()); } else { event.writeAsEncodedUnicode(writer); } } writer.flush(); writer.close(); res.setContent(new ByteArrayInputStream(content.toByteArray())); return res; }
public static void lerPeloStax() throws Exception { FileInputStream fileInputStream = new FileInputStream("src/venda.xml"); XMLInputFactory factory = XMLInputFactory.newInstance(); XMLEventReader eventos = factory.createXMLEventReader(fileInputStream); Produto produto = new Produto(); List<Produto> produtos = new ArrayList<>(); while (eventos.hasNext()) { XMLEvent evento = eventos.nextEvent(); if (evento.isStartElement() && evento.asStartElement().getName().getLocalPart().equals("produto")) { produto = new Produto(); } else if (evento.isStartElement() && evento.asStartElement().getName().getLocalPart().equals("nome")) { evento = eventos.nextEvent(); String nome = evento.asCharacters().getData(); produto.setNome(nome); } else if (evento.isStartElement() && evento.asStartElement().getName().getLocalPart().equals("preco")) { evento = eventos.nextEvent(); String nome = evento.asCharacters().getData(); produto.setPreco(Double.parseDouble(nome)); } else if (evento.isEndElement() && evento.asEndElement().getName().getLocalPart().equals("produto")) { produtos.add(produto); } } System.out.println(produtos); }
public static Address readConfig(InputStream in) { Address address = new Address(); try { // First create a new XMLInputFactory XMLInputFactory inputFactory = XMLInputFactory.newInstance(); // Setup a new eventReader // InputStream in = new FileInputStream(configFile); XMLEventReader eventReader = inputFactory.createXMLEventReader(in); // Read the XML document while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); if (event.isStartElement()) { if (event.asStartElement().getName().getLocalPart() == ("country")) { event = eventReader.nextEvent(); address.setCountry(event.asCharacters().getData()); continue; } if (event.asStartElement().getName().getLocalPart() == ("county")) { event = eventReader.nextEvent(); address.setCity(event.asCharacters().getData()); continue; } } } } catch (XMLStreamException e) { e.printStackTrace(); } return address; }
public InputStream addAtomInlinecount(final InputStream feed, final int count) throws Exception { final XMLEventReader reader = getEventReader(feed); final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final XMLEventWriter writer = getEventWriter(bos); try { final XMLElement feedElement = extractElement(reader, writer, Collections.<String>singletonList("feed"), 0, 1, 1) .getValue(); writer.add(feedElement.getStart()); addAtomElement( IOUtils.toInputStream(String.format("<m:count>%d</m:count>", count), Constants.ENCODING), writer); writer.add(feedElement.getContentReader()); writer.add(feedElement.getEnd()); while (reader.hasNext()) { writer.add(reader.nextEvent()); } } finally { writer.flush(); writer.close(); reader.close(); IOUtils.closeQuietly(feed); } return new ByteArrayInputStream(bos.toByteArray()); }
/** * Parse the {@link SAML11AttributeQueryType} * * @param xmlEventReader * @return * @throws ParsingException */ public static SAML11AuthenticationQueryType parseSAML11AuthenticationQuery( XMLEventReader xmlEventReader) throws ParsingException { SAML11AuthenticationQueryType query = new SAML11AuthenticationQueryType(); StartElement startElement; // There may be additional things under subject confirmation while (xmlEventReader.hasNext()) { XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader); if (xmlEvent instanceof EndElement) { EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader); if (StaxParserUtil.matches(endElement, SAML11Constants.AUTHENTICATION_QUERY)) break; else throw logger.parserUnknownEndElement(StaxParserUtil.getEndElementName(endElement)); } if (xmlEvent instanceof StartElement) { startElement = (StartElement) xmlEvent; String startTag = StaxParserUtil.getStartElementName(startElement); if (startTag.equals(JBossSAMLConstants.SUBJECT.get())) { SAML11SubjectParser parser = new SAML11SubjectParser(); query.setSubject((SAML11SubjectType) parser.parse(xmlEventReader)); } else throw logger.parserUnknownTag(startTag, startElement.getLocation()); } } return query; }
private void addAtomElement(final InputStream content, final XMLEventWriter writer) throws Exception { final XMLEventReader reader = getEventReader(content); final XMLEventFactory eventFactory = XMLEventFactory.newInstance(); XMLEvent newLine = eventFactory.createSpace("\n"); try { writer.add(newLine); while (reader.hasNext()) { final XMLEvent event = reader.nextEvent(); if (event.getEventType() != XMLStreamConstants.START_DOCUMENT && event.getEventType() != XMLStreamConstants.END_DOCUMENT && event.getEventType() != XMLStreamConstants.COMMENT) { writer.add(event); } } writer.add(newLine); } finally { reader.close(); IOUtils.closeQuietly(content); } }
/** The main purpose of this test is to ensure that an exception is thrown at the end. */ public void testIterationEndException() throws XMLStreamException { String XML = "<root />"; for (int i = 0; i < 4; ++i) { boolean coal = (i & 1) != 0; boolean checkHasNext = (i & 2) != 0; XMLEventReader er = getReader(XML, true, coal); assertTokenType(START_DOCUMENT, er.nextEvent().getEventType()); assertTokenType(START_ELEMENT, er.nextEvent().getEventType()); assertTokenType(END_ELEMENT, er.nextEvent().getEventType()); assertTokenType(END_DOCUMENT, er.nextEvent().getEventType()); if (checkHasNext) { assertFalse(er.hasNext()); } XMLEvent ev = null; try { ev = er.nextEvent(); } catch (NoSuchElementException nex) { continue; // good } catch (Throwable t) { fail("Expected a NoSuchElementException after iterating through the document; got " + t); } // Shouldn't get this far... fail( "Expected a NoSuchElementException after iterating through the document; got event: " + ev); } }
/** * Parse {@link org.keycloak.dom.saml.v1.assertion.SAML11ConditionsType} * * @param xmlEventReader * @return * @throws ParsingException */ public static SAML11ConditionsType parseSAML11Conditions(XMLEventReader xmlEventReader) throws ParsingException { StartElement startElement; SAML11ConditionsType conditions = new SAML11ConditionsType(); StartElement conditionsElement = StaxParserUtil.getNextStartElement(xmlEventReader); StaxParserUtil.validate(conditionsElement, JBossSAMLConstants.CONDITIONS.get()); String assertionNS = SAML11Constants.ASSERTION_11_NSURI; QName notBeforeQName = new QName("", JBossSAMLConstants.NOT_BEFORE.get()); QName notBeforeQNameWithNS = new QName(assertionNS, JBossSAMLConstants.NOT_BEFORE.get()); QName notAfterQName = new QName("", JBossSAMLConstants.NOT_ON_OR_AFTER.get()); QName notAfterQNameWithNS = new QName(assertionNS, JBossSAMLConstants.NOT_ON_OR_AFTER.get()); Attribute notBeforeAttribute = conditionsElement.getAttributeByName(notBeforeQName); if (notBeforeAttribute == null) notBeforeAttribute = conditionsElement.getAttributeByName(notBeforeQNameWithNS); Attribute notAfterAttribute = conditionsElement.getAttributeByName(notAfterQName); if (notAfterAttribute == null) notAfterAttribute = conditionsElement.getAttributeByName(notAfterQNameWithNS); if (notBeforeAttribute != null) { String notBeforeValue = StaxParserUtil.getAttributeValue(notBeforeAttribute); conditions.setNotBefore(XMLTimeUtil.parse(notBeforeValue)); } if (notAfterAttribute != null) { String notAfterValue = StaxParserUtil.getAttributeValue(notAfterAttribute); conditions.setNotOnOrAfter(XMLTimeUtil.parse(notAfterValue)); } while (xmlEventReader.hasNext()) { XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader); if (xmlEvent instanceof EndElement) { EndElement end = StaxParserUtil.getNextEndElement(xmlEventReader); if (StaxParserUtil.matches(end, JBossSAMLConstants.CONDITIONS.get())) break; } startElement = StaxParserUtil.peekNextStartElement(xmlEventReader); if (startElement == null) break; String tag = StaxParserUtil.getStartElementName(startElement); if (SAML11Constants.AUDIENCE_RESTRICTION_CONDITION.equals(tag)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); SAML11AudienceRestrictionCondition restrictCond = new SAML11AudienceRestrictionCondition(); startElement = StaxParserUtil.getNextStartElement(xmlEventReader); if (StaxParserUtil.getStartElementName(startElement) .equals(JBossSAMLConstants.AUDIENCE.get())) { restrictCond.add(URI.create(StaxParserUtil.getElementText(xmlEventReader))); } EndElement theEndElement = StaxParserUtil.getNextEndElement(xmlEventReader); StaxParserUtil.validate(theEndElement, SAML11Constants.AUDIENCE_RESTRICTION_CONDITION); conditions.add(restrictCond); } else throw logger.parserUnknownTag(tag, startElement.getLocation()); } return conditions; }
static boolean moveToResources(XMLEventReader eventReader) throws XMLStreamException { while (eventReader.hasNext()) { if (findNextStart(eventReader).getName().equals(TAG_RESOURCES)) { return true; } } return false; }
private void parseTerm(StartElement root, XMLEventReader r) throws IOException, XMLStreamException { Attribute aboutAtt = root.getAttributeByName(rdfAbout); if (aboutAtt == null) { throw new IOException("no rdf:about"); } TermImpl term = uri2term.get(aboutAtt.getValue()); if (term == null) { term = new TermImpl(); term.accession = aboutAtt.getValue(); if (term.accession.startsWith(PREFIX)) { term.accession = term.accession.substring(PREFIX.length()); } term.name = term.accession; uri2term.put(aboutAtt.getValue(), term); } while (r.hasNext()) { XMLEvent evt = r.nextEvent(); if (evt.isStartElement()) { StartElement E = evt.asStartElement(); QName qN = E.getName(); if (NS.equals(qN.getNamespaceURI())) { if (qN.getLocalPart().equals("accession")) { term.accession = r.getElementText(); } else if (qN.getLocalPart().equals("name")) { term.name = r.getElementText(); } else if (qN.getLocalPart().equals("is_a")) { Attribute rsrc = E.getAttributeByName(rdfRsrc); if (rsrc == null) throw new IOException("att missing " + rdfRsrc + " for " + aboutAtt.getValue()); String parentUri = rsrc.getValue(); term.parents.add(parentUri); TermImpl parentTerm = this.uri2term.get(parentUri); if (parentTerm == null) { parentTerm = new TermImpl(); parentTerm.accession = parentUri; if (parentTerm.accession.startsWith(PREFIX)) { parentTerm.accession = parentTerm.accession.substring(PREFIX.length()); } parentTerm.name = parentTerm.accession; uri2term.put(parentUri, parentTerm); } parentTerm.children.add(aboutAtt.getValue()); } } } else if (evt.isEndElement()) { EndElement E = evt.asEndElement(); QName qN = E.getName(); if (qN.getLocalPart().equals("term") && NS.equals(qN.getNamespaceURI())) { break; } } } }
public static KeyInfoType parseKeyInfo(XMLEventReader xmlEventReader) throws ParsingException { KeyInfoType keyInfo = new KeyInfoType(); StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader); StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.KEYINFO); XMLEvent xmlEvent = null; String tag = null; while (xmlEventReader.hasNext()) { xmlEvent = StaxParserUtil.peek(xmlEventReader); if (xmlEvent instanceof EndElement) { tag = StaxParserUtil.getEndElementName((EndElement) xmlEvent); if (tag.equals(WSTrustConstants.XMLDSig.KEYINFO)) { xmlEvent = StaxParserUtil.getNextEndElement(xmlEventReader); break; } else throw logger.parserUnknownEndElement(tag); } startElement = (StartElement) xmlEvent; tag = StaxParserUtil.getStartElementName(startElement); if (tag.equals(WSTrustConstants.XMLEnc.ENCRYPTED_KEY)) { keyInfo.addContent(StaxParserUtil.getDOMElement(xmlEventReader)); } else if (tag.equals(WSTrustConstants.XMLDSig.X509DATA)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); X509DataType x509 = new X509DataType(); // Let us go for the X509 certificate startElement = StaxParserUtil.getNextStartElement(xmlEventReader); StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.X509CERT); X509CertificateType cert = new X509CertificateType(); String certValue = StaxParserUtil.getElementText(xmlEventReader); cert.setEncodedCertificate(certValue.getBytes()); x509.add(cert); EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader); StaxParserUtil.validate(endElement, WSTrustConstants.XMLDSig.X509DATA); keyInfo.addContent(x509); } else if (tag.equals(WSTrustConstants.XMLDSig.KEYVALUE)) { startElement = StaxParserUtil.getNextStartElement(xmlEventReader); KeyValueType keyValue = null; startElement = StaxParserUtil.peekNextStartElement(xmlEventReader); tag = StaxParserUtil.getStartElementName(startElement); if (tag.equals(WSTrustConstants.XMLDSig.RSA_KEYVALUE)) { keyValue = parseRSAKeyValue(xmlEventReader); } else if (tag.equals(WSTrustConstants.XMLDSig.DSA_KEYVALUE)) { keyValue = parseDSAKeyValue(xmlEventReader); } else throw logger.parserUnknownTag(tag, startElement.getLocation()); EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader); StaxParserUtil.validate(endElement, WSTrustConstants.XMLDSig.KEYVALUE); keyInfo.addContent(keyValue); } } return keyInfo; }
static StartElement findNextStart(XMLEventReader eventReader) throws XMLStreamException { while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); if (event.isStartElement()) { return event.asStartElement(); } } return null; }
protected Map<String, Preference> toPreferencesMap(String xml) { if (Validator.isNull(xml)) { return Collections.emptyMap(); } Map<String, Preference> preferencesMap = _preferencesMapPortalCache.get(xml); if (preferencesMap != null) { return preferencesMap; } XMLEventReader xmlEventReader = null; try { XMLInputFactory xmlInputFactory = StAXReaderUtil.getXMLInputFactory(); xmlEventReader = xmlInputFactory.createXMLEventReader(new UnsyncStringReader(xml)); while (xmlEventReader.hasNext()) { XMLEvent xmlEvent = xmlEventReader.nextEvent(); if (xmlEvent.isStartElement()) { StartElement startElement = xmlEvent.asStartElement(); String elementName = startElement.getName().getLocalPart(); if (elementName.equals("preference")) { Preference preference = readPreference(xmlEventReader); if (preferencesMap == null) { preferencesMap = new HashMap<String, Preference>(); } preferencesMap.put(preference.getName(), preference); } } } } catch (XMLStreamException xse) { throw new SystemException(xse); } finally { if (xmlEventReader != null) { try { xmlEventReader.close(); } catch (XMLStreamException xse) { } } } if (preferencesMap == null) { preferencesMap = Collections.emptyMap(); } _preferencesMapPortalCache.put(xml, preferencesMap); return preferencesMap; }
@Override public InputStream replaceProperty( final InputStream src, final InputStream replacement, final List<String> path, final boolean justValue) throws Exception { final List<String> pathElements = new ArrayList<String>(); for (String element : path) { pathElements.add(Constants.get(ConstantKey.ATOM_PROPERTY_PREFIX) + element); } final XMLEventReader reader = getEventReader(src); final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final XMLEventWriter writer = getEventWriter(bos); final Map.Entry<Integer, XMLElement> element = extractElement(reader, writer, pathElements, 0, 3, 4); if (justValue) { writer.add(element.getValue().getStart()); } final XMLEventReader changesReader = new XMLEventReaderWrapper(replacement); while (changesReader.hasNext()) { final XMLEvent event = changesReader.nextEvent(); if (event.isStartElement() && event.asStartElement().getName().equals(element.getValue().getStart().getName())) { writer.add(element.getValue().getStart()); writer.add(changesReader); } else { writer.add(event); } } changesReader.close(); IOUtils.closeQuietly(replacement); if (justValue) { writer.add(element.getValue().getEnd()); } writer.add(reader); reader.close(); IOUtils.closeQuietly(src); writer.flush(); writer.close(); return new ByteArrayInputStream(bos.toByteArray()); }
/** Read TMX file. */ public void readTMX( File file, final Language sourceLanguage, final Language targetLanguage, boolean isSegmentingEnabled, final boolean forceOmegaTMX, final boolean extTmxLevel2, final boolean useSlash, final LoadCallback callback) throws Exception { this.extTmxLevel2 = extTmxLevel2; this.useSlash = useSlash; this.isSegmentingEnabled = isSegmentingEnabled; // log the parsing attempt Log.logRB("TMXR_INFO_READING_FILE", new Object[] {file.getAbsolutePath()}); boolean allFound = true; InputStream in; if (file.getName().endsWith(".gz")) { in = new BufferedInputStream(new GZIPInputStream(new FileInputStream(file))); } else { in = new BufferedInputStream(new FileInputStream(file)); } xml = factory.createXMLEventReader(in); try { while (xml.hasNext()) { XMLEvent e = xml.nextEvent(); switch (e.getEventType()) { case XMLEvent.START_ELEMENT: StartElement eStart = (StartElement) e; if ("tu".equals(eStart.getName().getLocalPart())) { parseTu(eStart); ParsedTuv origTuv = getTuvByLang(sourceLanguage); ParsedTuv targetTuv = getTuvByLang(targetLanguage); allFound &= callback.onEntry(currentTu, origTuv, targetTuv, isParagraphSegtype); } else if ("header".equals(eStart.getName().getLocalPart())) { parseHeader(eStart, sourceLanguage); } break; } } } finally { xml.close(); in.close(); } if (!allFound) { Log.logWarningRB("TMXR_WARNING_SOURCE_NOT_FOUND"); warningsCount++; } Log.logRB("TMXR_INFO_READING_COMPLETE"); Log.log(""); }
private void copyEvents(int length) throws IOException { try { while (reader.hasNext() && stream.getInputStream().available() < length) { writer.add(reader.nextEvent()); } writer.flush(); } catch (XMLStreamException e) { throw new be.re.io.IOException(e); } }
public DataMetadata parse(XMLEventReader xmlEventReader, StartElement start) throws GraphIOException { try { // Create the new port. DataMetadata data = new DataMetadata(); // Parse the attributes. @SuppressWarnings("unchecked") Iterator<Attribute> iterator = start.getAttributes(); while (iterator.hasNext()) { Attribute attribute = (Attribute) iterator.next(); String name = attribute.getName().getLocalPart(); String value = attribute.getValue(); if (data.getKey() == null && GraphMLConstants.KEY_NAME.equals(name)) { data.setKey(value); } } // Make sure the key has been set. if (data.getKey() == null) { throw new GraphIOException("Element 'data' is missing attribute 'key'"); } while (xmlEventReader.hasNext()) { XMLEvent event = xmlEventReader.nextEvent(); if (event.isStartElement()) { StartElement element = (StartElement) event; // Treat any child elements as unknown getUnknownParser().parse(xmlEventReader, element); } if (event.isCharacters()) { Characters characters = (Characters) event; data.setValue(characters.getData()); } if (event.isEndElement()) { EndElement end = (EndElement) event; verifyMatch(start, end); break; } } return data; } catch (Exception e) { ExceptionConverter.convert(e); } return null; }
public Amplitude(XMLEventReader reader) throws XMLStreamException, SeisFileException { StartElement startE = StaxUtil.expectStartElement(ELEMENT_NAME, reader); publicID = StaxUtil.pullAttribute(startE, QuakeMLTagNames.publicId); while (reader.hasNext()) { XMLEvent e = reader.peek(); if (e.isStartElement()) { String elName = e.asStartElement().getName().getLocalPart(); if (elName.equals(QuakeMLTagNames.comment)) { commentList.add(new Comment(reader)); } else if (elName.equals(QuakeMLTagNames.type)) { type = StaxUtil.pullText(reader, QuakeMLTagNames.type); } else if (elName.equals(QuakeMLTagNames.category)) { category = StaxUtil.pullText(reader, QuakeMLTagNames.category); } else if (elName.equals(QuakeMLTagNames.unit)) { unit = StaxUtil.pullText(reader, QuakeMLTagNames.unit); } else if (elName.equals(QuakeMLTagNames.methodID)) { methodID = StaxUtil.pullText(reader, QuakeMLTagNames.methodID); } else if (elName.equals(QuakeMLTagNames.snr)) { snr = StaxUtil.pullFloat(reader, QuakeMLTagNames.snr); } else if (elName.equals(QuakeMLTagNames.scalingTime)) { scalingTime = new Time(reader, QuakeMLTagNames.scalingTime); } else if (elName.equals(QuakeMLTagNames.timeWindow)) { timeWindow = new TimeWindow(reader); } else if (elName.equals(QuakeMLTagNames.waveformID)) { waveformID = new WaveformStreamID(reader, QuakeMLTagNames.waveformID); } else if (elName.equals(QuakeMLTagNames.filterID)) { filterID = StaxUtil.pullText(reader, QuakeMLTagNames.filterID); } else if (elName.equals(QuakeMLTagNames.magnitudeHint)) { magnitudeHint = StaxUtil.pullText(reader, QuakeMLTagNames.magnitudeHint); } else if (elName.equals(QuakeMLTagNames.pickID)) { pickID = StaxUtil.pullText(reader, QuakeMLTagNames.pickID); } else if (elName.equals(QuakeMLTagNames.period)) { period = new RealQuantity(reader, QuakeMLTagNames.period); } else if (elName.equals(QuakeMLTagNames.evaluationMode)) { evaluationMode = StaxUtil.pullText(reader, QuakeMLTagNames.evaluationMode); } else if (elName.equals(QuakeMLTagNames.evaluationStatus)) { evaluationStatus = StaxUtil.pullText(reader, QuakeMLTagNames.evaluationStatus); } else if (elName.equals(QuakeMLTagNames.genericAmplitude)) { genericAmplitude = new RealQuantity(reader, QuakeMLTagNames.genericAmplitude); } else if (elName.equals(QuakeMLTagNames.creationInfo)) { creationInfo = new CreationInfo(reader); } else { StaxUtil.skipToMatchingEnd(reader); } } else if (e.isEndElement()) { reader.nextEvent(); return; } else { e = reader.nextEvent(); } } }
/** * Read through a number of rows equal to the rowCacheSize field or until there is no more data to * read * * @return true if data was read */ private boolean getRow() { try { rowCache.clear(); while (rowCache.size() < rowCacheSize && parser.hasNext()) { handleEvent(parser.nextEvent()); } rowCacheIterator = rowCache.iterator(); return rowCacheIterator.hasNext(); } catch (XMLStreamException | SAXException e) { LOGGER.debug("End of stream"); } return false; }
public static void main(String[] args) { try { // FLUJO DE ESCRITURA XMLStreamWriter sw = XMLOutputFactory.newInstance().createXMLStreamWriter(new FileOutputStream("autores.xml")); // ESCRITURA sw.writeStartDocument("1.0"); sw.writeStartElement("autores"); sw.writeStartElement("autor"); sw.writeAttribute("codigo", "a1"); sw.writeStartElement("nome"); sw.writeCharacters("Alexandre Dumas"); sw.writeEndElement(); sw.writeStartElement("titulo"); sw.writeCharacters("El conde de montecristo"); sw.writeEndElement(); sw.writeStartElement("titulo"); sw.writeCharacters("Los miserables"); sw.writeEndElement(); sw.writeEndElement(); sw.writeStartElement("autor"); sw.writeAttribute("codigo", "a2"); sw.writeStartElement("nome"); sw.writeCharacters("Fiodor Dostoyevski"); sw.writeEndElement(); sw.writeStartElement("titulo"); sw.writeCharacters(" El idiota"); sw.writeEndElement(); sw.writeStartElement("titulo"); sw.writeCharacters("Noches blancas"); sw.writeEndDocument(); sw.flush(); sw.close(); // FLUJO DE LECTURA XMLEventReader er = XMLInputFactory.newInstance() .createXMLEventReader("autores.xml", new FileInputStream("autores.xml")); // LECTURA while (er.hasNext()) { System.out.println(er.nextEvent().toString()); } er.close(); } catch (XMLStreamException | FileNotFoundException ex) { Logger.getLogger(XMLprueba0.class.getName()).log(Level.SEVERE, null, ex); } }
public final ParserResult<T> parse(InputStream is, ParserTarget<T> target) throws Exception { XMLInputFactory factory = XMLInputFactory.newFactory(); XMLEventReader reader = factory.createXMLEventReader(is); while (reader.hasNext()) { XMLEvent event = reader.nextEvent(); handleEvent(event, reader, target); if (cancel) { break; } } return new ParserResult<>(target.getElementCount(), target.getElements(), type); }