示例#1
0
  /**
   * Return whether the given string contains well-formed XML.
   *
   * @param xmlString string to check
   * @return true iif the given string contains well-formed XML
   */
  public static boolean isWellFormedXML(String xmlString) {

    // Empty string is never well-formed XML
    if (xmlString.trim().length() == 0) return false;

    try {
      final XMLReader xmlReader = newSAXParser(XMLUtils.ParserConfiguration.PLAIN).getXMLReader();
      xmlReader.setContentHandler(NULL_CONTENT_HANDLER);
      xmlReader.setEntityResolver(ENTITY_RESOLVER);
      xmlReader.setErrorHandler(
          new org.xml.sax.ErrorHandler() {
            public void error(SAXParseException exception) throws SAXException {
              throw exception;
            }

            public void fatalError(SAXParseException exception) throws SAXException {
              throw exception;
            }

            public void warning(SAXParseException exception) throws SAXException {}
          });
      xmlReader.parse(new InputSource(new StringReader(xmlString)));
      return true;
    } catch (Exception e) {
      // Ideally we would like the parser to not throw as this is time-consuming, but not sure how
      // to achieve that
      return false;
    }
  }
 /*
  * Main method to parse specific MetaData file.
  */
 public Collection<Designate> doParse() throws IOException, SAXException {
   _dp_xmlReader = _dp_parser.getXMLReader();
   _dp_xmlReader.setContentHandler(new RootHandler());
   _dp_xmlReader.setErrorHandler(new MyErrorHandler(System.err));
   InputStream is = _dp_url.openStream();
   InputSource isource = new InputSource(is);
   logger.log(LogService.LOG_DEBUG, "Starting to parse " + _dp_url); // $NON-NLS-1$		
   _dp_xmlReader.parse(isource);
   return designates;
 }
示例#3
0
 public static XMLReader newXMLReader(XMLUtils.ParserConfiguration parserConfiguration) {
   final SAXParser saxParser = XMLUtils.newSAXParser(parserConfiguration);
   try {
     final XMLReader xmlReader = saxParser.getXMLReader();
     xmlReader.setEntityResolver(XMLUtils.ENTITY_RESOLVER);
     xmlReader.setErrorHandler(XMLUtils.ERROR_HANDLER);
     return xmlReader;
   } catch (Exception e) {
     throw new OXFException(e);
   }
 }
  /**
   * start the parsing
   *
   * @param file to parse
   * @return Vector containing the test cases
   */
  public XMLcpimParser() {
    try {
      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
      saxParser = saxParserFactory.newSAXParser().getXMLReader();
      saxParser.setContentHandler(this);
      saxParser.setFeature("http://xml.org/sax/features/validation", true);
      // parse the xml specification for the event tags.

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
示例#5
0
 public static void parseDocumentFragment(Reader reader, XMLReceiver xmlReceiver)
     throws SAXException {
   try {
     final XMLReader xmlReader = newSAXParser(XMLUtils.ParserConfiguration.PLAIN).getXMLReader();
     xmlReader.setContentHandler(new XMLFragmentReceiver(xmlReceiver));
     final ArrayList<Reader> readers = new ArrayList<Reader>(3);
     readers.add(new StringReader("<root>"));
     readers.add(reader);
     readers.add(new StringReader("</root>"));
     xmlReader.parse(new InputSource(new SequenceReader(readers.iterator())));
   } catch (IOException e) {
     throw new OXFException(e);
   }
 }
示例#6
0
 public static void parseDocumentFragment(String fragment, XMLReceiver xmlReceiver)
     throws SAXException {
   if (fragment.indexOf("<") != -1 || fragment.indexOf("&") != -1) {
     try {
       final XMLReader xmlReader = newSAXParser(XMLUtils.ParserConfiguration.PLAIN).getXMLReader();
       xmlReader.setContentHandler(new XMLFragmentReceiver(xmlReceiver));
       xmlReader.parse(new InputSource(new StringReader("<root>" + fragment + "</root>")));
     } catch (IOException e) {
       throw new OXFException(e);
     }
   } else {
     // Optimization when fragment looks like text
     xmlReceiver.characters(fragment.toCharArray(), 0, fragment.length());
   }
 }
示例#7
0
 public int runXmlImport() {
   DataImportXmlParser responseHandler = null;
   try {
     XMLReader parser = EfaUtil.getXMLReader();
     responseHandler = new DataImportXmlParser(this, dataAccess);
     parser.setContentHandler(responseHandler);
     parser.parse(new InputSource(new FileInputStream(filename)));
   } catch (Exception e) {
     logInfo(e.toString());
     errorCount++;
     Logger.log(e);
     if (Daten.isGuiAppl()) {
       Dialog.error(e.toString());
     }
   }
   return (responseHandler != null ? responseHandler.getImportedRecordsCount() : 0);
 }
 public void parseCPIMString(String body) {
   try {
     StringReader stringReader = new StringReader(body);
     InputSource inputSource = new InputSource(stringReader);
     saxParser.parse(inputSource);
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
  /**
   * start the parsing
   *
   * @param file to parse
   * @return Vector containing the test cases
   */
  public XMLcpimParser(String fileLocation) {
    try {
      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
      saxParser = saxParserFactory.newSAXParser().getXMLReader();
      saxParser.setContentHandler(this);
      saxParser.setFeature("http://xml.org/sax/features/validation", true);
      // parse the xml specification for the event tags.
      saxParser.parse(fileLocation);

    } catch (SAXParseException spe) {
      spe.printStackTrace();
    } catch (SAXException sxe) {
      sxe.printStackTrace();
    } catch (IOException ioe) {
      // I/O error
      ioe.printStackTrace();
    } catch (Exception pce) {
      // Parser with specified options can't be built
      pce.printStackTrace();
    }
  }
示例#10
0
  /**
   * This will create a SAX XMLReader capable of parsing a DTD and configure it so that the DTD
   * parsing events are routed to the handlers registered onto this SAXOutputter.
   *
   * @return <code>XMLReader</code> a SAX2 parser.
   * @throws JDOMException if no parser can be created.
   */
  private XMLReader createDTDParser() throws JDOMException {
    XMLReader parser = null;

    // Get a parser instance
    try {
      parser = createParser();
    } catch (Exception ex1) {
      throw new JDOMException("Error in SAX parser allocation", ex1);
    }

    // Register handlers
    if (this.getDTDHandler() != null) {
      parser.setDTDHandler(this.getDTDHandler());
    }
    if (this.getEntityResolver() != null) {
      parser.setEntityResolver(this.getEntityResolver());
    }
    if (this.getLexicalHandler() != null) {
      try {
        parser.setProperty(SAX_PROPERTY_LEXICAL_HANDLER, this.getLexicalHandler());
      } catch (SAXException ex1) {
        try {
          parser.setProperty(SAX_PROPERTY_LEXICAL_HANDLER_ALT, this.getLexicalHandler());
        } catch (SAXException ex2) {
          // Forget it!
        }
      }
    }
    if (this.getDeclHandler() != null) {
      try {
        parser.setProperty(SAX_PROPERTY_DECLARATION_HANDLER, this.getDeclHandler());
      } catch (SAXException ex1) {
        try {
          parser.setProperty(SAX_PROPERTY_DECLARATION_HANDLER_ALT, this.getDeclHandler());
        } catch (SAXException ex2) {
          // Forget it!
        }
      }
    }

    // Absorb errors as much as possible, per Laurent
    parser.setErrorHandler(new DefaultHandler());

    return parser;
  }
示例#11
0
  private static void inputSourceToSAX(
      InputSource inputSource,
      XMLReceiver xmlReceiver,
      XMLUtils.ParserConfiguration parserConfiguration,
      boolean handleLexical) {

    // Insert XInclude processor if needed
    final TransformerURIResolver resolver;
    if (parserConfiguration.handleXInclude) {
      parserConfiguration =
          new XMLUtils.ParserConfiguration(
              parserConfiguration.validating,
              false,
              parserConfiguration.externalEntities,
              parserConfiguration.uriReferences);
      resolver = new TransformerURIResolver(XMLUtils.ParserConfiguration.PLAIN);
      xmlReceiver =
          new XIncludeReceiver(null, xmlReceiver, parserConfiguration.uriReferences, resolver);
    } else {
      resolver = null;
    }

    try {
      final XMLReader xmlReader = newSAXParser(parserConfiguration).getXMLReader();
      xmlReader.setContentHandler(xmlReceiver);
      if (handleLexical) xmlReader.setProperty(XMLConstants.SAX_LEXICAL_HANDLER, xmlReceiver);

      xmlReader.setEntityResolver(ENTITY_RESOLVER);
      xmlReader.setErrorHandler(ERROR_HANDLER);
      xmlReader.parse(inputSource);
    } catch (SAXParseException e) {
      throw new ValidationException(e.getMessage(), new LocationData(e));
    } catch (Exception e) {
      throw new OXFException(e);
    } finally {
      if (resolver != null) resolver.destroy();
    }
  }
  protected static void addXml(
      final SolrInputDocument doc,
      final String fieldprefix,
      final String textfield,
      InputSource input)
      throws SAXException, IOException {
    XMLReader reader = XMLReaderFactory.createXMLReader();

    final StringBuilder text = new StringBuilder();

    reader.setContentHandler(
        new ContentHandler() {

          final Deque<String> parents = new LinkedList<String>();

          final Deque<StringBuilder> element_texts = new LinkedList<StringBuilder>();

          private String path() {
            StringBuilder sb = new StringBuilder(fieldprefix);

            for (String el : parents) {
              sb.append('/');
              sb.append(el);
            }

            return sb.toString();
          }

          public void startPrefixMapping(String prefix, String uri) throws SAXException {}

          public void startDocument() throws SAXException {}

          public void skippedEntity(String name) throws SAXException {}

          public void setDocumentLocator(Locator locator) {}

          public void processingInstruction(String target, String data) throws SAXException {}

          public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
            text.append(ch, start, length);

            element_texts.getLast().append(ch, start, length);
          }

          public void endPrefixMapping(String prefix) throws SAXException {}

          public void endElement(String uri, String localName, String qName) throws SAXException {
            addxmltext(doc, path(), element_texts.removeLast());
            parents.removeLast();
          }

          public void endDocument() throws SAXException {
            addxmltext(doc, textfield, text);
          }

          public void characters(char[] ch, int start, int length) throws SAXException {
            text.append(ch, start, length);
            text.append(' ');

            element_texts.getLast().append(ch, start, length);
          }

          public void startElement(String uri, String localName, String qName, Attributes atts)
              throws SAXException {

            // ignore namespaces when constructing field names
            parents.addLast(localName);
            element_texts.addLast(new StringBuilder());

            for (int i = 0; i < atts.getLength(); i++) {
              String attr_field = path() + "@" + atts.getLocalName(i);
              doc.addField(attr_field, atts.getValue(i));
            }
          }
        });

    reader.setErrorHandler(
        new ErrorHandler() {

          public void warning(SAXParseException exception) throws SAXException {
            // TODO log?
            throw exception;
          }

          public void fatalError(SAXParseException exception) throws SAXException {
            throw exception;
          }

          public void error(SAXParseException exception) throws SAXException {
            throw exception;
          }
        });

    reader.parse(input);
  }