示例#1
0
  /**
   * This test was inspired by an actual bug in one of implementations: initial state was not
   * properly set if nextTag() was called (instead of nextEvent()), and subsequent peek() failed.
   */
  public void testPeek() throws XMLStreamException {
    String XML = "<root>text</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());

      XMLEvent tag = er.nextTag();
      assertTokenType(START_ELEMENT, tag.getEventType());

      // Now, peek() should produce text..
      XMLEvent text = er.peek();
      assertTokenType(CHARACTERS, text.getEventType());
      Characters chars = text.asCharacters();
      assertNotNull(chars);
      assertEquals("text", chars.getData());

      // and need nextEvent() to get rid of it, too:
      text = er.nextEvent();
      // Let's verify it again:
      assertTokenType(CHARACTERS, text.getEventType());
      chars = text.asCharacters();
      assertNotNull(chars);
      assertEquals("text", chars.getData());
      assertTokenType(END_ELEMENT, er.nextTag().getEventType());
      assertTokenType(END_DOCUMENT, er.nextEvent().getEventType());

      // And at the end, peek() should return null
      assertNull(er.peek());
    }
  }
示例#2
0
  @SuppressWarnings({"unchecked"})
  private JaxbHibernateConfiguration unmarshal(
      XMLEventReader staxEventReader, final Origin origin) {
    XMLEvent event;
    try {
      event = staxEventReader.peek();
      while (event != null && !event.isStartElement()) {
        staxEventReader.nextEvent();
        event = staxEventReader.peek();
      }
    } catch (Exception e) {
      throw new HibernateException("Error accessing stax stream", e);
    }

    if (event == null) {
      throw new HibernateException("Could not locate root element");
    }

    if (!isNamespaced(event.asStartElement())) {
      // if the elements are not namespaced, wrap the reader in a reader which will namespace them
      // as pulled.
      log.debug(
          "cfg.xml document did not define namespaces; wrapping in custom event reader to introduce namespace information");
      staxEventReader =
          new NamespaceAddingEventReader(staxEventReader, HIBERNATE_CONFIGURATION_URI);
    }

    final Object target;
    final ContextProvidingValidationEventHandler handler =
        new ContextProvidingValidationEventHandler();
    try {
      JAXBContext jaxbContext = JAXBContext.newInstance(JaxbHibernateConfiguration.class);
      Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
      unmarshaller.setSchema(schema());
      unmarshaller.setEventHandler(handler);
      target = unmarshaller.unmarshal(staxEventReader);
      return (JaxbHibernateConfiguration) target;
    } catch (JAXBException e) {
      StringBuilder builder = new StringBuilder();
      builder
          .append("Unable to perform unmarshalling at line number ")
          .append(handler.getLineNumber())
          .append(" and column ")
          .append(handler.getColumnNumber())
          .append(" in ")
          .append(origin.getType().name())
          .append(" ")
          .append(origin.getName())
          .append(". Message: ")
          .append(handler.getMessage());
      throw new ConfigurationException(builder.toString(), e);
    }
  }
示例#3
0
  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());
    }
  }
示例#4
0
  private Object unmarshal0(XMLEventReader reader, JaxBeanInfo expectedType) throws JAXBException {
    if (reader == null) {
      throw new IllegalArgumentException(Messages.format(Messages.NULL_READER));
    }

    try {
      XMLEvent event = reader.peek();

      if (!event.isStartElement() && !event.isStartDocument()) {
        // TODO: convert event into event name
        throw new IllegalStateException(
            Messages.format(Messages.ILLEGAL_READER_STATE, event.getEventType()));
      }

      // Quick hack until SJSXP fixes 6270116
      boolean isZephyr = reader.getClass().getName().equals("com.sun.xml.stream.XMLReaderImpl");
      XmlVisitor h = createUnmarshallerHandler(null, false, expectedType);
      if (!isZephyr) {
        h = new InterningXmlVisitor(h);
      }
      new StAXEventConnector(reader, h).bridge();
      return h.getContext().getResult();
    } catch (XMLStreamException e) {
      throw handleStreamException(e);
    }
  }
示例#5
0
  public void testElementText() throws XMLStreamException {
    String TEXT1 = "some\ntest";
    String TEXT2 = "inside CDATA too!";

    String XML = "<root>" + TEXT1 + "<![CDATA[" + TEXT2 + "]]></root>";

    // First, let's see how things work without peeking:
    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());
      XMLEvent elem = er.nextEvent();
      assertTokenType(START_ELEMENT, elem.getEventType());

      try {
        assertEquals(TEXT1 + TEXT2, er.getElementText());
      } catch (XMLStreamException sex) {
        fail("Failed on XMLEventReader.getElementText(): " + sex);
      }

      /* 06-Jan-2006, TSa: I'm really not sure whether to expect
       *   END_ELEMENT, or END_DOCUMENT here... maybe the latter
       *   makes more sense? For now let's accept both, however.
       */
      elem = er.nextEvent();
      if (elem.getEventType() != END_DOCUMENT && elem.getEventType() != END_ELEMENT) {
        fail("Expected END_DOCUMENT or END_ELEMENT, got " + tokenTypeDesc(elem.getEventType()));
      }
    }

    // and then with peeking:
    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());
      XMLEvent elem = er.nextEvent();
      assertTokenType(START_ELEMENT, elem.getEventType());
      XMLEvent peeked = er.peek();
      assertTokenType(CHARACTERS, peeked.getEventType());
      assertEquals(TEXT1 + TEXT2, er.getElementText());

      /* 06-Jan-2006, TSa: I'm really not sure whether to expect
       *   END_ELEMENT, or END_DOCUMENT here... maybe the latter
       *   makes more sense? For now let's accept both, however.
       */
      elem = er.nextEvent();

      if (elem.getEventType() != END_DOCUMENT && elem.getEventType() != END_ELEMENT) {
        fail("Expected END_DOCUMENT or END_ELEMENT, got " + tokenTypeDesc(elem.getEventType()));
      }
    }
  }
示例#6
0
 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();
     }
   }
 }
  @Override
  protected OAIPMHtype parseElement(XMLEventReader reader) throws ParseException {
    OAIPMHtype pmh = new OAIPMHtype();

    try {
      if (!reader.peek().asStartElement().getName().getLocalPart().equals(NAME))
        throw new ParseException("Expecting " + NAME + " element");

      reader.nextEvent();
      this.nextElement(reader);

      pmh.setResponseDate(
          super.getConfiguration().getFormatter().parse(this.getElement(reader, RESPONSE_DATE)));
      pmh.setRequest(reqParser.parse(reader));

      String name = reader.peek().asStartElement().getName().getLocalPart();

      if (name.equals("ListRecords")) pmh.setListRecords(listRecordsParser.parse(reader));
      else if (name.equals("GetRecord")) pmh.setGetRecord(getRecordParser.parse(reader));
      else if (name.equals("ListIdentifiers"))
        pmh.setListIdentifiers(listIdentifiersParser.parse(reader));
      else if (name.equals("ListSets")) pmh.setListSets(listSetsParser.parse(reader));
      else if (name.equals("ListMetadataFormats"))
        pmh.setListMetadataFormats(listMetadataFormatsParser.parse(reader));
      else if (name.equals("Identify")) pmh.setIdentify(identifyParser.parse(reader));
      else {
        while (reader.peek().asStartElement().getName().getLocalPart().equals("error")) {
          pmh.getError().add(errorParser.parse(reader));
        }
      }

    } catch (XMLStreamException e) {
      throw new ParseException(e);
    } catch (java.text.ParseException e) {
      throw new ParseException(e);
    }

    return pmh;
  }
示例#8
0
  private static StringBuilder readCharacters(XMLEventReader eventReader)
      throws XMLStreamException {
    StringBuilder buffer = new StringBuilder();

    XMLEvent next;
    do {
      next = eventReader.nextEvent();
      String data = next.asCharacters().getData();
      buffer.append(data.trim());

      next = eventReader.peek();
    } while (next != null && next.isCharacters());

    return buffer;
  }
 public ResponseListElement(XMLEventReader reader) throws XMLStreamException, StationXMLException {
   StartElement startE = StaxUtil.expectStartElement(StationXMLTagNames.POLESZEROS, reader);
   while (reader.hasNext()) {
     XMLEvent e = reader.peek();
     if (e.isStartElement()) {
       String elName = e.asStartElement().getName().getLocalPart();
       if (elName.equals(StationXMLTagNames.FREQUENCY)) {
         frequency = StaxUtil.pullFloat(reader, StationXMLTagNames.FREQUENCY);
       } else if (elName.equals(StationXMLTagNames.AMPLITUDE)) {
         amplitude = StaxUtil.pullFloat(reader, StationXMLTagNames.AMPLITUDE);
       } else if (elName.equals(StationXMLTagNames.PHASE)) {
         phase = StaxUtil.pullFloat(reader, StationXMLTagNames.PHASE);
       } else {
         StaxUtil.skipToMatchingEnd(reader);
       }
     } else if (e.isEndElement()) {
       reader.nextEvent();
       return;
     } else {
       e = reader.nextEvent();
     }
   }
 }
  /**
   * Check to see if the next even is just a new line character. If so add it to the end of the last
   * events string.
   */
  private void checkForNewLine() {

    preWhiteSpace = "";
    postWhiteSpace = "";

    if (hasNext()) { // If there is a next event...
      try {
        XMLEvent event = parser.peek(); // ...peek at it and...
        String eventString = event.toString(); // ...get it's character representation.

        // Then if the next event is just a new ling and whitespace...
        if (eventString.matches(UNIX_NEW_LINE_REGEXP)
            || eventString.matches(SYSTEM_NEW_LINE_REGEXP)) {
          // Record the whitespace that needs to be placed before the next real element.
          preWhiteSpace = eventString.substring(eventString.indexOf('\n') + 1);
          // Record the whitespace that needs to be placed after this element.
          postWhiteSpace = eventString.substring(0, eventString.indexOf('\n') + 1);
          parser.nextEvent(); // Lastly move on to the next element what ever it may be.
        }
      } catch (XMLStreamException e) {
        System.out.println("SORT THIS OUT!: " + e.getMessage());
      }
    }
  }
示例#11
0
  public void testSkip() throws XMLStreamException {
    String XML =
        "<?xml version='1.0' ?><!DOCTYPE root><root>\n"
            + "<branch>   <leaf>  </leaf></branch><!-- comment -->"
            + "</root>";

    for (int i = 0; i < 4; ++i) {
      boolean ns = (i & 1) != 0;
      boolean coal = (i & 2) != 0;
      XMLEventReader er = getReader(XML, ns, coal);
      XMLEvent ev;

      assertTokenType(START_DOCUMENT, er.peek().getEventType());
      assertTokenType(START_DOCUMENT, er.nextEvent().getEventType());
      assertTokenType(DTD, er.peek().getEventType());
      assertTokenType(DTD, er.nextEvent().getEventType());
      assertTokenType(START_ELEMENT, er.peek().getEventType());
      assertTokenType(START_ELEMENT, er.nextEvent().getEventType());

      assertTokenType(CHARACTERS, er.peek().getEventType());
      assertTokenType(CHARACTERS, er.nextEvent().getEventType());

      // branch
      assertTokenType(START_ELEMENT, er.peek().getEventType());
      assertTokenType(START_ELEMENT, er.nextEvent().getEventType());
      assertTokenType(CHARACTERS, er.peek().getEventType());
      assertTokenType(CHARACTERS, er.nextEvent().getEventType());

      // leaf
      assertTokenType(START_ELEMENT, er.peek().getEventType());
      assertTokenType(START_ELEMENT, er.nextEvent().getEventType());
      assertTokenType(CHARACTERS, er.peek().getEventType());
      assertTokenType(CHARACTERS, er.nextEvent().getEventType());
      assertTokenType(END_ELEMENT, er.peek().getEventType());
      assertTokenType(END_ELEMENT, er.nextEvent().getEventType());

      assertTokenType(END_ELEMENT, er.peek().getEventType());
      assertTokenType(END_ELEMENT, er.nextEvent().getEventType());

      assertTokenType(COMMENT, er.peek().getEventType());
      assertTokenType(COMMENT, er.nextEvent().getEventType());
      assertTokenType(END_ELEMENT, er.peek().getEventType());
      assertTokenType(END_ELEMENT, er.nextEvent().getEventType());

      assertTokenType(END_DOCUMENT, er.peek().getEventType());
      assertTokenType(END_DOCUMENT, er.nextEvent().getEventType());
      assertFalse(er.hasNext());
    }
  }
 public void parse(XMLEventReader input) throws XMLStreamException, XNIException {
   XMLEvent currentEvent = input.peek();
   if (currentEvent != null) {
     int eventType = currentEvent.getEventType();
     if (eventType != XMLStreamConstants.START_DOCUMENT
         && eventType != XMLStreamConstants.START_ELEMENT) {
       throw new XMLStreamException();
     }
     fLocationWrapper.setLocation(currentEvent.getLocation());
     fSchemaDOMParser.startDocument(fLocationWrapper, null, fNamespaceContext, null);
     loop:
     while (input.hasNext()) {
       currentEvent = input.nextEvent();
       eventType = currentEvent.getEventType();
       switch (eventType) {
         case XMLStreamConstants.START_ELEMENT:
           ++fDepth;
           StartElement start = currentEvent.asStartElement();
           fillQName(fElementQName, start.getName());
           fLocationWrapper.setLocation(start.getLocation());
           fNamespaceContext.setNamespaceContext(start.getNamespaceContext());
           fillXMLAttributes(start);
           fillDeclaredPrefixes(start);
           addNamespaceDeclarations();
           fNamespaceContext.pushContext();
           fSchemaDOMParser.startElement(fElementQName, fAttributes, null);
           break;
         case XMLStreamConstants.END_ELEMENT:
           EndElement end = currentEvent.asEndElement();
           fillQName(fElementQName, end.getName());
           fillDeclaredPrefixes(end);
           fLocationWrapper.setLocation(end.getLocation());
           fSchemaDOMParser.endElement(fElementQName, null);
           fNamespaceContext.popContext();
           --fDepth;
           if (fDepth <= 0) {
             break loop;
           }
           break;
         case XMLStreamConstants.CHARACTERS:
           sendCharactersToSchemaParser(currentEvent.asCharacters().getData(), false);
           break;
         case XMLStreamConstants.SPACE:
           sendCharactersToSchemaParser(currentEvent.asCharacters().getData(), true);
           break;
         case XMLStreamConstants.CDATA:
           fSchemaDOMParser.startCDATA(null);
           sendCharactersToSchemaParser(currentEvent.asCharacters().getData(), false);
           fSchemaDOMParser.endCDATA(null);
           break;
         case XMLStreamConstants.PROCESSING_INSTRUCTION:
           ProcessingInstruction pi = (ProcessingInstruction) currentEvent;
           fillProcessingInstruction(pi.getData());
           fSchemaDOMParser.processingInstruction(pi.getTarget(), fTempString, null);
           break;
         case XMLStreamConstants.DTD:
           /* There shouldn't be a DTD in the schema */
           break;
         case XMLStreamConstants.ENTITY_REFERENCE:
           /* Not needed for schemas */
           break;
         case XMLStreamConstants.COMMENT:
           /* No point in sending comments */
           break;
         case XMLStreamConstants.START_DOCUMENT:
           fDepth++;
           /* We automatically call startDocument before the loop */
           break;
         case XMLStreamConstants.END_DOCUMENT:
           /* We automatically call endDocument after the loop */
           break;
       }
     }
     fLocationWrapper.setLocation(null);
     fNamespaceContext.setNamespaceContext(null);
     fSchemaDOMParser.endDocument(null);
   }
 }
 private static void untilFirstStartElement(XMLEventReader reader) throws XMLStreamException {
   while (reader.peek() != null
       && !reader.peek().isStartElement()
       && !reader.peek().isEndDocument()) reader.nextEvent();
 }
示例#14
0
 public static XMLEvent peekNextTag(XMLEventReader eventReader) throws XMLStreamException {
   while (!(eventReader.peek().isEndElement() || eventReader.peek().isStartElement())) {
     eventReader.nextEvent();
   }
   return eventReader.peek();
 }