Beispiel #1
0
  /**
   * Annotates a block of values of a heatmap.plus SVG file by giving them an id and row/column
   * attributes. A heatmap.plus can contain up to three 'blocks': row annotations, column
   * annotations and the matrix.
   *
   * @param nRow number of rows of this block
   * @param nCol number of columns of this block
   * @param blockId value of the id attribute to give elements in this block
   * @throws XMLStreamException
   */
  private void annotateHeatMapBlock(
      int nRow, int nCol, String blockId, XMLEventWriter writer, XMLEventReader reader)
      throws XMLStreamException {
    int counter = 0;
    int nPath = nRow * nCol;
    int currentRow = nRow; // elements drawn from bottom to top, so start counting at last row
    int currentCol = 1;
    while (counter < nPath) {
      XMLEvent event = (XMLEvent) reader.next();
      if (event.isStartElement() && event.asStartElement().getName().getLocalPart().equals(PATH)) {
        // make a new start element with the same attributes plus the extra annotations
        @SuppressWarnings("unchecked")
        Iterator<Attribute> attributes = event.asStartElement().getAttributes();

        StartElement newSe = eventFactory.createStartElement(new QName(PATH), attributes, null);
        writer.add(newSe);
        writer.add(eventFactory.createAttribute(ID, blockId));
        writer.add(eventFactory.createAttribute(new QName("row"), Integer.toString(currentRow)));
        writer.add(eventFactory.createAttribute(new QName("col"), Integer.toString(currentCol)));

        currentRow--;
        if (currentRow == 0) {
          // finished one column, reset currentRow and increment currentCol
          currentRow = nRow;
          currentCol++;
        }
        counter++;
      } else {
        // write the rest untouched
        writer.add(event);
      }
    }
  }
  public static String xmlToJson(String xml, boolean formatted) throws XMLStreamException {
    InputStream input = new ByteArrayInputStream(xml.getBytes());
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    JsonXMLConfig config =
        new JsonXMLConfigBuilder()
            .autoArray(true)
            .autoPrimitive(true)
            .prettyPrint(formatted)
            .build();

    try {
      XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(input);
      XMLEventWriter writer = new JsonXMLOutputFactory(config).createXMLEventWriter(output);
      writer.add(reader);
      reader.close();
      writer.close();
      try {
        return output.toString("UTF-8");
      } catch (UnsupportedEncodingException e) {
        throw new XMLStreamException(e.getMessage());
      }
    } finally {
      // dp nothing
    }
  }
  @Override
  public InputStream deleteProperty(final InputStream src, final List<String> path)
      throws Exception {
    final XMLEventReader reader = getEventReader(src);

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    final XMLEventWriter writer = getEventWriter(bos);

    final XMLEventReader changesReader =
        new XMLEventReaderWrapper(
            IOUtils.toInputStream(
                String.format("<%s m:null=\"true\" />", path.get(path.size() - 1)),
                Constants.ENCODING));

    writer.add(changesReader);
    changesReader.close();

    writer.add(reader);

    reader.close();
    IOUtils.closeQuietly(src);

    writer.flush();
    writer.close();

    return new ByteArrayInputStream(bos.toByteArray());
  }
  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);
    }
  }
  public XmlWriter(File output) throws FileNotFoundException, WriterException {
    this.xmlFile = output;
    System.out.println("setting up xml");
    if (output.exists()) {
      System.out.println("deleting existing file: " + output);
      output.delete();
    }

    try {
      FileOutputStream fos = new FileOutputStream(output);
      XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
      eventWriter = outputFactory.createXMLEventWriter(fos);

      eventFactory = XMLEventFactory.newInstance();

      end = eventFactory.createDTD("\n");

      // Create and write Start Tag
      StartDocument startDocument = eventFactory.createStartDocument();
      eventWriter.add(startDocument);

      StartElement configStartElement = eventFactory.createStartElement("", "", DOC_ELEMENT_NAME);
      eventWriter.add(configStartElement);
      eventWriter.add(end);
    } catch (XMLStreamException e) {
      throw new WriterException("unable to instantiate writer to file: " + output, e);
    }
  }
  @Override
  public void writeStats(MessageType message) {

    XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent end = eventFactory.createDTD("\n");
    XMLEvent tab = eventFactory.createDTD("\t");
    // Create Start node

    List<Attribute> attrs = new LinkedList<Attribute>();

    attrs.add(eventFactory.createAttribute(REQUEST_NUM_ATTR_NAME, "" + countLine++));
    for (Stat stat : message.getValues()) {
      attrs.add(eventFactory.createAttribute(stat.getKey(), "" + stat.getValue()));
    }

    final Iterator<Attribute> attrIt = attrs.iterator();

    StartElement sElement =
        eventFactory.createStartElement(
            "", "", REQUEST_ELEMENT_NAME, attrIt, Collections.<Namespace>emptyList().iterator());
    try {
      eventWriter.add(tab);
      eventWriter.add(sElement);
      // Create End node
      EndElement eElement = eventFactory.createEndElement("", "", REQUEST_ELEMENT_NAME);
      eventWriter.add(eElement);
      eventWriter.add(end);
    } catch (XMLStreamException e) {
      throw new RuntimeException("ERROR IN WRITING XML: ", e);
    }
  }
  public static String marshal(
      Object msg, String msgQName, String msgLocalName, String[] userPackages) throws Exception {

    TreeSet<String> contextPackages = new TreeSet<String>();
    for (int i = 0; i < userPackages.length; i++) {
      String userPackage = userPackages[i];
      contextPackages.add(userPackage);
    }

    JAXBContext jaxbContext =
        JAXBUtils.getJAXBContext(
            contextPackages,
            constructionType,
            contextPackages.toString(),
            XmlUtils.class.getClassLoader(),
            new HashMap<String, Object>());
    Marshaller marshaller = JAXBUtils.getJAXBMarshaller(jaxbContext);

    JAXBElement jaxbRequest =
        new JAXBElement(new QName(msgQName, msgLocalName), msg.getClass(), msg);
    Writer writer = new StringWriter();

    // Support XMLDsig
    XMLEventWriter xmlWriter = staxOF.createXMLEventWriter(writer);
    marshaller.marshal(jaxbRequest, xmlWriter);
    xmlWriter.flush();
    JAXBUtils.releaseJAXBMarshaller(jaxbContext, marshaller);

    return writer.toString();
  }
  /**
   * Creates the node.
   *
   * @param eventWriter the event writer
   * @param name the name
   * @param d the d
   * @param string2 the string2
   * @param string3 the string3
   * @throws XMLStreamException the xML stream exception
   */
  private void createNode(
      final XMLEventWriter eventWriter,
      final String name,
      final HashMap<String, String> d,
      final String string2,
      final String string3)
      throws XMLStreamException {

    XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent end = eventFactory.createCharacters("\n");
    XMLEvent tab = eventFactory.createCharacters("\t");
    // Create Start node
    StartElement sElement = eventFactory.createStartElement(string2, string3, name);
    eventWriter.add(tab);
    eventWriter.add(sElement);
    // FIXME nullpointer abfangen!!1
    eventWriter.add(end);

    for (String str : d.keySet()) {
      createNode(eventWriter, "docPart", d.get(str), str, PREFIX, URI);
    }
    if (d.isEmpty()) {
      createNode(eventWriter, "docPart", "", "de", PREFIX, URI);
    }
    eventWriter.add(eventFactory.createEndElement(string2, string3, name));
    eventWriter.add(end);
  }
  @Override
  public Scenario parse(InputStream inputStream)
      throws IOException, SAXException, ParserConfigurationException {

    OutputStream output = new ByteArrayOutputStream();
    JsonXMLConfig config = new JsonXMLConfigBuilder().autoArray(true).prettyPrint(false).build();

    try {

      /* Create source (XML). */
      XMLEventReader reader = XMLInputFactory.newInstance().createXMLEventReader(inputStream);
      // XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(inputStream);
      // Source source = new StAXSource(reader);

      /* Create result (JSON). */
      XMLEventWriter writer = new JsonXMLOutputFactory(config).createXMLEventWriter(output);
      // XMLStreamWriter writer = new JsonXMLOutputFactory(config).createXMLStreamWriter(output);
      // Result result = new StAXResult(writer);

      /*
       * Copy events from reader to writer.
       */
      writer.add(reader);

      /* Copy source to result via "identity transform". */
      // TransformerFactory.newInstance().newTransformer().transform(source, result);
    } catch (XMLStreamException e) {
      e.printStackTrace();
    } finally {

      /* As per StAX specification, XMLStreamReader/Writer.close()
      doesn't close
      the underlying stream. */
      output.close();
      inputStream.close();
    }

    /*
    try {
        json = xmlToJson(inputStream);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    String jsonString = json.toString();

    System.out.println(jsonString);

    GenericDocument genericDocument = new GenericDocument();
    genericDocument.setJson(jsonString);
    */

    GenericDocument genericDocument = new GenericDocument();
    String json = output.toString();

    genericDocument.setJson(json);

    return genericDocument;
  }
 private void putValue(RelationalProfile.Column column, ResultSet resultSet, int indent)
     throws XMLStreamException, SQLException {
   String value = getValue(column, resultSet);
   if (value == null) return;
   while (indent-- > 0) out.add(event.createCharacters("   "));
   out.add(event.createStartElement("", "", column.name, null, null));
   out.add(event.createCharacters(value));
   out.add(event.createEndElement("", "", column.name));
   out.add(event.createCharacters("\n"));
 }
  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);
    }
  }
  /** {@inheritDoc } */
  @Override
  protected InputStream addLinks(
      final String entitySetName,
      final String entitykey,
      final InputStream is,
      final Set<String> links)
      throws Exception {

    // -----------------------------------------
    // 0. Build reader and writer
    // -----------------------------------------
    final XMLEventReader reader = getEventReader(is);
    final XMLEventFactory eventFactory = XMLEventFactory.newInstance();

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    final XMLEventWriter writer = getEventWriter(bos);
    // -----------------------------------------
    final Map.Entry<Integer, XMLElement> entry =
        extractElement(reader, writer, Collections.singletonList("entry"), 0, 1, 1);

    writer.add(entry.getValue().getStart());

    final Map<String, NavigationProperty> navigationProperties =
        metadata.getNavigationProperties(entitySetName);

    // add for links
    for (String link : links) {
      final Set<Attribute> attributes = new HashSet<Attribute>();
      attributes.add(eventFactory.createAttribute(new QName("title"), link));
      attributes.add(
          eventFactory.createAttribute(
              new QName("href"), Commons.getLinksURI(entitySetName, entitykey, link)));
      attributes.add(
          eventFactory.createAttribute(
              new QName("rel"), Constants.get(ConstantKey.ATOM_LINK_REL) + link));
      attributes.add(
          eventFactory.createAttribute(
              new QName("type"),
              navigationProperties.get(link).isEntitySet()
                  ? Constants.get(ConstantKey.ATOM_LINK_FEED)
                  : Constants.get(ConstantKey.ATOM_LINK_ENTRY)));

      writer.add(
          eventFactory.createStartElement(
              new QName(Constants.get(ConstantKey.LINK)), attributes.iterator(), null));
      writer.add(eventFactory.createEndElement(new QName(Constants.get(ConstantKey.LINK)), null));
    }

    writer.add(entry.getValue().getContentReader());
    writer.add(entry.getValue().getEnd());
    writer.add(reader);
    IOUtils.closeQuietly(is);

    writer.flush();
    writer.close();
    reader.close();

    return new ByteArrayInputStream(bos.toByteArray());
  }
Beispiel #13
0
  @Override
  public void close() throws WriterException {

    try {
      eventWriter.add(eventFactory.createEndElement("", "", DOC_ELEMENT_NAME));
      eventWriter.add(end);
      eventWriter.add(eventFactory.createEndDocument());
      eventWriter.close();
    } catch (XMLStreamException e) {
      throw new WriterException("unable to close stream for file: " + xmlFile, e);
    }
  }
  /**
   * Write a new element with the specified name and text
   *
   * @return the end element
   */
  private XMLEvent getAddedEvent(
      XMLEvent event, XMLEventWriter writer, String elementName, String text)
      throws XMLStreamException {
    StartElement oldStartEvent = event.asStartElement();
    StartElement newStartEvent =
        xmlEventFactory.createStartElement(
            new QName(elementName), null, oldStartEvent.getNamespaces());

    writer.add(newStartEvent);
    writer.add(xmlEventFactory.createCharacters(text));
    return xmlEventFactory.createEndElement(newStartEvent.getName(), newStartEvent.getNamespaces());
  }
  @Override
  protected InputStream replaceLink(
      final InputStream toBeChanged, final String linkName, final InputStream replacement)
      throws Exception {
    final XMLEventReader reader = getEventReader(toBeChanged);

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    final XMLEventWriter writer = getEventWriter(bos);

    final XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent newLine = eventFactory.createSpace("\n");

    try {
      final XMLElement linkElement =
          extractElement(
                  reader,
                  writer,
                  Collections.<String>singletonList(Constants.get(ConstantKey.LINK)),
                  Collections.<Map.Entry<String, String>>singletonList(
                      new SimpleEntry<String, String>("title", linkName)),
                  false,
                  0,
                  -1,
                  -1)
              .getValue();
      writer.add(linkElement.getStart());

      // ------------------------------------------
      // write inline ...
      // ------------------------------------------
      writer.add(newLine);
      writer.add(eventFactory.createStartElement("m", null, "inline"));

      addAtomElement(replacement, writer);

      writer.add(eventFactory.createEndElement("m", null, "inline"));
      writer.add(newLine);
      // ------------------------------------------

      writer.add(linkElement.getEnd());

      writer.add(reader);
      writer.flush();
      writer.close();
    } finally {
      reader.close();
      IOUtils.closeQuietly(toBeChanged);
    }

    return new ByteArrayInputStream(bos.toByteArray());
  }
 protected byte[] object2WbXml(
     Object o,
     WbXmlDefinition def,
     WbXmlVersion version,
     WbXmlEncoder.StrtblType encoderType,
     boolean skipSpaces,
     boolean event)
     throws Exception {
   XMLStreamWriter xmlStreamWriter = null;
   XMLEventWriter xmlEventWriter = null;
   ByteArrayOutputStream out = null;
   try {
     out = new ByteArrayOutputStream();
     outFact.setProperty(WbXmlOutputFactory.ENCODING_TYPE_PROPERTY, encoderType);
     outFact.setProperty(WbXmlOutputFactory.SKIP_SPACES_PROPERTY, skipSpaces);
     outFact.setProperty(WbXmlOutputFactory.VERSION_PROPERTY, version);
     outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
     if (event) {
       xmlEventWriter = outFact.createXMLEventWriter(out);
     } else {
       xmlStreamWriter = outFact.createXMLStreamWriter(out);
     }
     JAXBContext jc = JAXBContext.newInstance(o.getClass());
     Marshaller marshaller = jc.createMarshaller();
     if (event) {
       marshaller.marshal(o, xmlEventWriter);
     } else {
       marshaller.marshal(o, xmlStreamWriter);
     }
     return out.toByteArray();
   } finally {
     if (out != null) {
       try {
         out.close();
       } catch (Exception e) {
       }
     }
     if (xmlStreamWriter != null) {
       try {
         xmlStreamWriter.close();
       } catch (Exception e) {
       }
     }
     if (xmlEventWriter != null) {
       try {
         xmlEventWriter.close();
       } catch (Exception e) {
       }
     }
   }
 }
  @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());
  }
  @Override
  public InputStream addEditLink(final InputStream content, final String title, final String href)
      throws Exception {

    final ByteArrayOutputStream copy = new ByteArrayOutputStream();
    IOUtils.copy(content, copy);
    IOUtils.closeQuietly(content);

    XMLEventReader reader = getEventReader(new ByteArrayInputStream(copy.toByteArray()));

    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    XMLEventWriter writer = getEventWriter(bos);

    final String editLinkElement =
        String.format("<link rel=\"edit\" title=\"%s\" href=\"%s\" />", title, href);

    try {
      // check edit link existence
      extractElement(
          reader,
          writer,
          Collections.<String>singletonList(Constants.get(ConstantKey.LINK)),
          Collections.<Map.Entry<String, String>>singletonList(
              new AbstractMap.SimpleEntry<String, String>("rel", "edit")),
          false,
          0,
          -1,
          -1);

      addAtomElement(IOUtils.toInputStream(editLinkElement, Constants.ENCODING), writer);
      writer.add(reader);

    } catch (Exception e) {
      reader.close();
      reader = getEventReader(new ByteArrayInputStream(copy.toByteArray()));

      bos = new ByteArrayOutputStream();
      writer = getEventWriter(bos);

      final XMLElement entryElement =
          extractElement(reader, writer, Collections.<String>singletonList("entry"), 0, 1, 1)
              .getValue();

      writer.add(entryElement.getStart());

      addAtomElement(IOUtils.toInputStream(editLinkElement, Constants.ENCODING), writer);

      writer.add(entryElement.getContentReader());
      writer.add(entryElement.getEnd());

      writer.add(reader);

      writer.flush();
      writer.close();
    } finally {
      reader.close();
    }

    return new ByteArrayInputStream(bos.toByteArray());
  }
 protected byte[] doc2WbXml(
     Document doc,
     WbXmlDefinition def,
     WbXmlVersion version,
     WbXmlEncoder.StrtblType encoderType,
     boolean skipSpaces,
     boolean event)
     throws Exception {
   XMLStreamWriter xmlStreamWriter = null;
   XMLEventWriter xmlEventWriter = null;
   ByteArrayOutputStream out = null;
   try {
     out = new ByteArrayOutputStream();
     outFact.setProperty(WbXmlOutputFactory.ENCODING_TYPE_PROPERTY, encoderType);
     outFact.setProperty(WbXmlOutputFactory.SKIP_SPACES_PROPERTY, skipSpaces);
     outFact.setProperty(WbXmlOutputFactory.VERSION_PROPERTY, version);
     outFact.setProperty(WbXmlOutputFactory.DEFINITION_PROPERTY, def);
     if (event) {
       xmlEventWriter = outFact.createXMLEventWriter(out);
     } else {
       xmlStreamWriter = outFact.createXMLStreamWriter(out);
     }
     Transformer xformer = TransformerFactory.newInstance().newTransformer();
     Source domSource = new DOMSource(doc);
     StAXResult staxResult =
         (event) ? new StAXResult(xmlEventWriter) : new StAXResult(xmlStreamWriter);
     xformer.transform(domSource, staxResult);
     return out.toByteArray();
   } finally {
     if (out != null) {
       try {
         out.close();
       } catch (Exception e) {
       }
     }
     if (xmlStreamWriter != null) {
       try {
         xmlStreamWriter.close();
       } catch (Exception e) {
       }
     }
     if (xmlEventWriter != null) {
       try {
         xmlEventWriter.close();
       } catch (Exception e) {
       }
     }
   }
 }
  public void testSetPrefix() throws XMLStreamException {

    String uri = "uri";
    String prefix = "prefix";
    xmlEventWriter.setPrefix(prefix, uri);
    eventWriterWrapper.setPrefix(prefix, uri);
  }
  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());
  }
  /**
   * Creates the node.
   *
   * @param eventWriter the event writer
   * @param name the name
   * @param value the value
   * @param lang the lang
   * @param string2 the string2
   * @param string3 the string3
   * @throws XMLStreamException the xML stream exception
   */
  private void createNode(
      final XMLEventWriter eventWriter,
      final String name,
      final String value,
      final String lang,
      final String string2,
      final String string3)
      throws XMLStreamException {
    XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEvent end = eventFactory.createCharacters("\n");
    XMLEvent tab = eventFactory.createCharacters("\t");
    // Create Start node
    StartElement sElement = eventFactory.createStartElement(string2, string3, name);
    eventWriter.add(tab);
    eventWriter.add(sElement);
    eventWriter.add(eventFactory.createAttribute("xml:lang", lang));
    eventWriter.add(end);

    if (value.trim().length() > 0) {
      Characters characters = eventFactory.createCharacters(value.trim());
      eventWriter.add(characters);
    }
    eventWriter.add(eventFactory.createEndElement(string2, string3, name));
    eventWriter.add(end);
  }
  public void testObjectToXMLEventWriter() throws Exception {
    if (XML_OUTPUT_FACTORY != null) {
      StringWriter writer = new StringWriter();

      XMLOutputFactory factory = XMLOutputFactory.newInstance();
      factory.setProperty(factory.IS_REPAIRING_NAMESPACES, new Boolean(false));
      XMLEventWriter eventWriter = factory.createXMLEventWriter(writer);

      Object objectToWrite = getWriteControlObject();
      XMLDescriptor desc = null;
      if (objectToWrite instanceof XMLRoot) {
        desc =
            (XMLDescriptor)
                xmlContext
                    .getSession(0)
                    .getProject()
                    .getDescriptor(((XMLRoot) objectToWrite).getObject().getClass());
      } else {
        desc =
            (XMLDescriptor)
                xmlContext.getSession(0).getProject().getDescriptor(objectToWrite.getClass());
      }
      jaxbMarshaller.setProperty(MarshallerProperties.MEDIA_TYPE, "application/xml");

      int sizeBefore = getNamespaceResolverSize(desc);
      try {
        jaxbMarshaller.marshal(objectToWrite, eventWriter);
      } catch (Exception e) {
        assertMarshalException(e);
        return;
      }
      if (expectsMarshalException) {
        fail("An exception should have occurred but didn't.");
        return;
      }

      eventWriter.flush();
      int sizeAfter = getNamespaceResolverSize(desc);

      assertEquals(sizeBefore, sizeAfter);
      Document testDocument = getTestDocument(writer.toString());
      writer.close();
      objectToXMLDocumentTest(testDocument);
    }
  }
 private void writeEvent(final XMLEvent event, final XMLEventWriter writer) {
   if (writer != null) {
     try {
       writer.add(event);
     } catch (XMLStreamException e) {
       LOG.error("Error writing event {}", event, e);
     }
   }
 }
 private void addMessageIdElement(XMLEventWriter writer, String id, StartElement startElement)
     throws XMLStreamException {
   writer.add(
       eventFactory.createStartElement(
           "",
           startElement.getName().getNamespaceURI(),
           startElement.getName().getLocalPart(),
           startElement.getAttributes(),
           startElement.getNamespaces(),
           startElement.getNamespaceContext()));
   writer.add(eventFactory.createCharacters(id));
   writer.add(
       eventFactory.createEndElement(
           "",
           startElement.getName().getNamespaceURI(),
           startElement.getName().getLocalPart(),
           startElement.getNamespaces()));
 }
 private void addRewrittenAddressElement(
     XMLEventWriter writer, String address, int port, StartElement startElement)
     throws XMLStreamException {
   writer.add(
       eventFactory.createStartElement(
           "",
           startElement.getName().getNamespaceURI(),
           startElement.getName().getLocalPart(),
           startElement.getAttributes(),
           startElement.getNamespaces(),
           startElement.getNamespaceContext()));
   writer.add(eventFactory.createCharacters(address.replaceFirst(":\\d+/", ":" + port + "/")));
   writer.add(
       eventFactory.createEndElement(
           "",
           startElement.getName().getNamespaceURI(),
           startElement.getName().getLocalPart(),
           startElement.getNamespaces()));
 }
 /* (non-Javadoc)
  * @see org.springframework.batch.item.xml.StaxWriterCallback#write(javax.xml.stream.XMLEventWriter)
  */
 @Override
 public void write(XMLEventWriter writer) throws IOException {
   XMLEventFactory factory = XMLEventFactory.newInstance();
   try {
     writer.add(
         factory.createComment(
             "Total write count = " + stepExecution.getWriteCount() + ";credit 201310 end."));
   } catch (XMLStreamException e) {
     e.printStackTrace();
   }
 }
  public void rewriteEndpoint(Reader reader, Writer writer, int port, Exchange exc)
      throws XMLStreamException {
    XMLEventReader parser = inputFactory.createXMLEventReader(reader);
    XMLEventWriter eventWriter = XMLOutputFactory.newInstance().createXMLEventWriter(writer);

    String id = null;
    String url = null;

    skip:
    while (parser.hasNext()) {
      XMLEvent e = parser.nextEvent();

      if (e.isStartElement()) {
        if (isReplyTo(e.asStartElement())) {
          while (e.isStartElement() || !isReplyTo(e.asEndElement())) {
            if (e.isStartElement() && isAddress(e.asStartElement())) {
              url = parser.getElementText();
              addRewrittenAddressElement(eventWriter, url, port, e.asStartElement());

              continue skip;
            }

            eventWriter.add(e);
            e = parser.nextTag();
          }
        }

        if (isMessageId(e.asStartElement())) {
          id = parser.getElementText();
          exc.setProperty("messageId", id);
          addMessageIdElement(eventWriter, id, e.asStartElement());

          continue skip;
        }
      }

      eventWriter.add(e);
    }

    registry.register(id, url);
  }
  private void read(Source source) throws IOException, XMLStreamException {

    // Read in XML, extracting and removing the updates list in the process
    StringWriter buffer = new StringWriter(BUFFER_SIZE);
    XMLEventWriter eventWriter = this.xmlOutputFactory.createXMLEventWriter(buffer);
    XMLEventReader eventReader = this.xmlInputFactory.createXMLEventReader(source);
    UpdatesXMLEventReader updatesReader = new UpdatesXMLEventReader(eventReader);
    eventWriter.add(updatesReader);
    eventWriter.close();
    eventReader.close();

    // Was the update list found?
    List<String> updateNames = updatesReader.getUpdates();
    if (updateNames == null)
      throw new PersistentObjectException("XML file does not contain an updates list");

    // Save current content (without updates) and updates list
    this.current = buffer.toString();
    this.updates.clear();
    this.updates.addAll(updateNames);
  }
Beispiel #30
0
  private void writeContours(XMLEventWriter writer, XMLEvent indent, TDRStructure structure) {

    XMLEventFactory efac = XMLEventFactory.newInstance();

    Collection<XMLEvent> attrContour = new ArrayList<XMLEvent>();
    XMLEvent startContour;
    XMLEvent endContour = efac.createEndElement("", "", "contour");

    Vector<TDRContour> contours = structure.getContours();
    Iterator<TDRContour> it = contours.iterator();

    try {

      while (it.hasNext()) {
        TDRContour contour = it.next();
        String section = String.valueOf(contour.getSection().getNumber());
        String startpoint = contour.get_startpoint_x() + "," + contour.get_startpoint_y();
        String offset = String.valueOf(contour.get_offset());
        String numpoints = String.valueOf(contour.get_numpoints());

        /* prepare contour's attributes */
        attrContour.clear(); /*clear existing attributes*/
        attrContour.add(efac.createAttribute("section", section));
        attrContour.add(efac.createAttribute("startpoint", startpoint));
        attrContour.add(efac.createAttribute("offset", offset));
        attrContour.add(efac.createAttribute("numpoints", numpoints));
        startContour = efac.createStartElement("", "", "contour", attrContour.iterator(), null);

        /*<contour>*/
        writer.add(indent);
        writer.add(startContour);
        writer.add(endContour);
        writer.add(newLine);
      }

    } catch (XMLStreamException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }