Java Code Examples for org.xml.sax.InputSource

public void parse(File xml,AirSigmet airSigmet){
  try {
    airSigmet.fetchTime=xml.lastModified();
    InputSource input=new InputSource(new FileReader(xml));
    SAXParserFactory factory=SAXParserFactory.newInstance();
    SAXParser parser=factory.newSAXParser();
    AirSigmetHandler handler=new AirSigmetHandler(airSigmet);
    XMLReader xmlReader=parser.getXMLReader();
    xmlReader.setContentHandler(handler);
    xmlReader.parse(input);
  }
 catch (  Exception e) {
  }
}
 

public Element getOsis(Key key,SwordBookMetaData sbmd) throws BookException {
  try {
    String plain=getRawText(key);
    StringReader in=new StringReader("<div>" + plain + "</div>");
    InputSource is=new InputSource(in);
    SAXBuilder builder=new SAXBuilder();
    Document doc=builder.build(is);
    Element div=doc.getRootElement();
    return div;
  }
 catch (  Exception e) {
    throw new BookException(UserMsg.READ_FAIL,e,new Object[]{key.getName()});
  }
}
 

/** 
 * Parses input stream as an RSS 2.0 feed.
 * @return in-memory representation of an RSS feed
 * @throws IllegalArgumentException if either argument is {@code null}
 */
private RSSFeed parse(SAXParser parser,InputStream feed) throws SAXException, IOException {
  if (parser == null) {
    throw new IllegalArgumentException("RSS parser must not be null.");
  }
 else   if (feed == null) {
    throw new IllegalArgumentException("RSS feed must not be null.");
  }
  final InputSource source=new InputSource(feed);
  final XMLReader xmlreader=parser.getXMLReader();
  final RSSHandler handler=new RSSHandler(config);
  xmlreader.setContentHandler(handler);
  xmlreader.parse(source);
  return handler.feed();
}
 

private InputSource resolveInClasspath(String publicId,String systemId) throws SAXException, IOException {
  InputSource result=resolveInClasspath(publicId);
  if (result == null) {
    result=resolveInClasspath(systemId);
  }
  if (result == null) {
    result=new InputSource(new ByteArrayInputStream("<?xml version='1.0' encoding='UTF-8'?>".getBytes("UTF-8")));
  }
  return result;
}
 

protected Node getNodeLine(String xmlSample) throws Exception {
  DocumentBuilderFactory docBuilderFactory=DocumentBuilderFactory.newInstance();
  DocumentBuilder docBuilder=null;
  docBuilder=docBuilderFactory.newDocumentBuilder();
  StringReader ir=new StringReader(xmlSample);
  InputSource is=new InputSource(ir);
  Document doc=docBuilder.parse(is);
  doc.normalize();
  return doc.getFirstChild();
}
 

private Document loadDoc(InputStream in) throws ParserConfigurationException, SAXException, IOException {
  DocumentBuilderFactory fact=DocumentBuilderFactory.newInstance();
  DocumentBuilder builder=fact.newDocumentBuilder();
  InputSource is=new InputSource(in);
  is.setSystemId(CATALOG_FILENAME);
  return builder.parse(is);
}
 

/** 
 * Parses input stream as an RSS 2.0 feed.
 * @return in-memory representation of an RSS feed
 * @throws IllegalArgumentException if either argument is {@code null}
 */
private RSSFeed parse(SAXParser parser,InputStream feed) throws SAXException, IOException {
  if (parser == null) {
    throw new IllegalArgumentException("RSS parser must not be null.");
  }
 else   if (feed == null) {
    throw new IllegalArgumentException("RSS feed must not be null.");
  }
  final InputSource source=new InputSource(feed);
  final XMLReader xmlreader=parser.getXMLReader();
  final RSSHandler handler=new RSSHandler(config);
  xmlreader.setContentHandler(handler);
  xmlreader.parse(source);
  return handler.feed();
}
 

/** 
 * Gets the document.
 * @param xml the xml
 * @return the document
 */
public static Document getDocument(String xml){
  StringReader reader=new StringReader(xml);
  InputSource inputStream=new InputSource(reader);
  Document doc;
  try {
synchronized (DOCUMENT_BUILDER) {
      doc=DOCUMENT_BUILDER.parse(inputStream);
    }
  }
 catch (  Exception e) {
    throw new Cts2RuntimeException(e);
  }
  return doc;
}
 

/** 
 * Parse an input stream for blueprint xml. 
 * @param inputStream The data to parse. The caller is responsible for closing the stream afterwards. 
 * @throws Exception on parse error
 */
public void parse(InputStream inputStream) throws Exception {
  InputSource inputSource=new InputSource(inputStream);
  DocumentBuilder builder=getDocumentBuilderFactory().newDocumentBuilder();
  Document doc=builder.parse(inputSource);
  documents.add(doc);
}
 

public static void main(final String[] args) throws Exception {
  URL url;
  url=new URL("http://www.l3s.de/web/page11g.do?sp=page11g&link=ln104g&stu1g.LanguageISOCtxParam=en");
  final InputSource is=HTMLFetcher.fetch(url).toInputSource();
  final BoilerpipeSAXInput in=new BoilerpipeSAXInput(is);
  final TextDocument doc=in.getTextDocument();
  System.out.println(ArticleExtractor.INSTANCE.getText(doc));
}
 

public static void main(final String[] args) throws Exception {
  URL url;
  url=new URL("http://www.l3s.de/web/page11g.do?sp=page11g&link=ln104g&stu1g.LanguageISOCtxParam=en");
  final InputSource is=HTMLFetcher.fetch(url).toInputSource();
  final BoilerpipeSAXInput in=new BoilerpipeSAXInput(is);
  final TextDocument doc=in.getTextDocument();
  System.out.println(ArticleExtractor.INSTANCE.getText(doc));
}
 

@Override public InputSource resolveEntity(String publicId,String systemId) throws SAXException, IOException {
  InputSource entity=null;
  if (null != systemId) {
    entity=resolveSystemId(systemId);
  }
  return entity;
}
 

void loadBroadcastGenericSelectorPreference(){
  if (PreferenceFactory.containsPreferenceId(BROADCAST_SELECTOR_PREFERENCE_ID)) {
    return;
  }
  InputSource inputSource=new InputSource(getClass().getResourceAsStream(BROADCAST_SELECTOR_PREFERENCE_FILE));
  madGuiPlugin.getConfiguration().addPreferenceMapping(inputSource);
}
 

void loadImportPreferences(){
  if (PreferenceFactory.containsPreferenceId(FIELD_IMPORT_PREFERENCE_ID) && PreferenceFactory.containsPreferenceId(IMPORT_SETTINGS_PREFERENCE_ID)) {
    return;
  }
  InputSource inputSource=new InputSource(getClass().getResourceAsStream(IMPORT_PREFERENCE_FILE_NAME));
  madGuiPlugin.getConfiguration().addPreferenceMapping(inputSource);
}
 

private void loadPreferences(){
  if (containsPreferenceId(CLASSIFICATION_WINDOW_PREFERENCE_ID) && containsPreferenceId(CLASS_STRUCT_WINDOW_PREFERENCE_ID)) {
    return;
  }
  InputSource inputSource=new InputSource(getClass().getResourceAsStream(PREFERENCE_FILE_NAME));
  madGuiPlugin.getConfiguration().addPreferenceMapping(inputSource);
}
 

@Override protected Document extractDomDocument(String content) throws Exception {
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  DocumentBuilder builder=factory.newDocumentBuilder();
  InputSource is=new InputSource(new StringReader(extractString(content)));
  return builder.parse(is);
}
 

/** 
 * Transform to InputSource.
 * @param inStream Input Stream.
 * @return InputSource.
 */
@Transformer public InputSource toInputSource(InputStream inStream){
  byte[] bytes=toBytes(inStream);
  InputSource inputSource=new InputSource();
  inputSource.setByteStream(new ByteArrayInputStream(bytes));
  return inputSource;
}
 

public InputSource resolveEntity(String publicId,String systemId) throws SAXException, IOException {
  String entity=null;
  if (publicIDPrefer_ && publicId != null && publicId.length() != 0)   entity=publicIDs_.get(publicId);
  if (entity == null && systemId != null && systemId.length() != 0)   entity=systemIDs_.get(systemId);
  if (entity == null && publicId != null && publicId.length() != 0)   entity=publicIDs_.get(publicId);
  if (entity != null) {
    if (PrivilegedSystemHelper.getResource(entity) != null) {
      InputSource src=new InputSource(PrivilegedSystemHelper.getResourceAsStream(entity));
      src.setSystemId(PrivilegedSystemHelper.getResource(entity).getPath());
      return src;
    }
  }
  return null;
}
 

public List<HashMap<String,String>> parse(String xml) throws Exception {
  if (xml == null) {
    return null;
  }
  mData=new ArrayList<HashMap<String,String>>();
  InputSource inputSource=new InputSource(new StringReader(xml));
  SAXParserFactory spf=SAXParserFactory.newInstance();
  SAXParser sp=spf.newSAXParser();
  XMLReader xr=sp.getXMLReader();
  xr.setContentHandler(this);
  xr.parse(inputSource);
  return mData;
}
 

/** 
 * Turn an XML String into a DOM.
 * @param xml The xml String.
 * @return A XML Document.
 * @throws SAXException In case of invalid XML.
 */
public static Document getDocument(String xml) throws SAXException {
  try {
    DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
    return documentBuilder.parse(new InputSource(new StringReader(xml)));
  }
 catch (  ParserConfigurationException e) {
    throw new IllegalStateException("Parser not configured",e);
  }
catch (  IOException e) {
    throw new IllegalStateException("IOException on read-from-memory",e);
  }
}
 

static protected Lesson parseXML(File file,String default_name) throws Exception {
  XMLReader xr=XMLReaderFactory.createXMLReader();
  FCParser fcp=new FCParser();
  xr.setContentHandler(fcp);
  xr.setErrorHandler(fcp);
  FileReader r=new FileReader(file);
  xr.parse(new InputSource(r));
  String name=fcp.getName();
  if (name == "")   name=default_name;
  String description=fcp.getDesc();
  return new Lesson(fcp.getCards(),name,description);
}
 

void parseRSS(InputStream feed){
  XMLReader parser=null;
  try {
    parser=XMLReaderFactory.createXMLReader();
    parser.setContentHandler(getRSSContentHandler());
    parser.parse(new InputSource(feed));
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
catch (  SAXException e) {
    e.printStackTrace();
  }
}
 

@Override protected RSSFeed doInBackground(String... RSSuri){
  try {
    URL url=new URL(RSSuri[0]);
    SAXParserFactory factory=SAXParserFactory.newInstance();
    SAXParser parser=factory.newSAXParser();
    XMLReader xmlreader=parser.getXMLReader();
    RSSHandler theRssHandler=new RSSHandler();
    xmlreader.setContentHandler(theRssHandler);
    InputSource is=new InputSource(url.openStream());
    xmlreader.parse(is);
    return theRssHandler.getFeed();
  }
 catch (  Exception ee) {
    return null;
  }
}
 

/** 
 * Process the META-INF/context.xml descriptor in the web application root. This descriptor is not processed when a webapp is added programmatically through a StandardContext
 */
protected void applicationContextConfig(){
  ServletContext servletContext=context.getServletContext();
  InputStream stream=servletContext.getResourceAsStream("/" + Constants.ApplicationContextXml);
  if (stream == null) {
    return;
  }
synchronized (contextDigester) {
    URL url=null;
    try {
      url=servletContext.getResource("/" + Constants.ApplicationContextXml);
    }
 catch (    MalformedURLException e) {
      throw new AssertionError("/" + Constants.ApplicationContextXml + " should not be considered a malformed URL");
    }
    InputSource is=new InputSource(url.toExternalForm());
    is.setByteStream(stream);
    contextDigester.push(context);
    try {
      contextDigester.parse(is);
    }
 catch (    Exception e) {
      ok=false;
      log.error("Parse error in context.xml for " + context.getName(),e);
    }
 finally {
      contextDigester.reset();
      try {
        if (stream != null) {
          stream.close();
        }
      }
 catch (      IOException e) {
        log.error("Error closing context.xml for " + context.getName(),e);
      }
    }
  }
  log.debug("Done processing " + Constants.ApplicationContextXml + " descriptor");
}
 

private ProtocolMetaData parseForProtocolMetaData(String xmlResponse) throws XPathExpressionException {
  final ProtocolMetaData protocolMetaData=new ProtocolMetaData();
  final HTTPContext httpContext=new HTTPContext(this.configuration.getRemoteServerAddress(),this.configuration.getRemoteServerHttpPort());
  final XPath xpath=XPathFactory.newInstance().newXPath();
  NodeList servlets=(NodeList)xpath.evaluate("/map/entry[@key = 'properties']/map/entry[@value = 'Servlet']",new InputSource(new StringReader(xmlResponse)),XPathConstants.NODESET);
  for (int i=0; i < servlets.getLength(); i++) {
    httpContext.add(new Servlet(servlets.item(i).getAttributes().getNamedItem("key").getNodeValue(),this.deploymentName));
  }
  protocolMetaData.addContext(httpContext);
  return protocolMetaData;
}
 

/** 
 * Turn an XML String into a DOM.
 * @param xml The xml String.
 * @return A XML Document.
 * @throws SAXException In case of invalid XML.
 */
public static Document getDocument(String xml) throws SAXException {
  try {
    DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
    return documentBuilder.parse(new InputSource(new StringReader(xml)));
  }
 catch (  ParserConfigurationException e) {
    throw new IllegalStateException("Parser not configured",e);
  }
catch (  IOException e) {
    throw new IllegalStateException("IOException on read-from-memory",e);
  }
}
 

private static Document getDocument(String doc) throws ParserConfigurationException, SAXException, IOException {
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  factory.setNamespaceAware(true);
  DocumentBuilder documentbuilder=factory.newDocumentBuilder();
  return documentbuilder.parse(new InputSource(new StringReader(doc)));
}
 

Element stringToElement(String s) throws Exception {
  StringReader sreader=new StringReader(s);
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  DocumentBuilder parser=factory.newDocumentBuilder();
  Document doc=parser.parse(new InputSource(sreader));
  return doc.getDocumentElement();
}
 

private static Document parseXmlToDocument(String xml) throws RuntimeException {
  DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
  builderFactory.setNamespaceAware(true);
  try {
    DocumentBuilder builder=builderFactory.newDocumentBuilder();
    InputSource is=new InputSource(new StringReader(xml));
    return builder.parse(is);
  }
 catch (  SAXException e) {
    throw new RuntimeException("Parsing XML failed: " + e + ", xml: "+ xml,e);
  }
catch (  IOException e) {
    throw new RuntimeException("Parsing XML failed: " + e + ", xml: "+ xml,e);
  }
catch (  ParserConfigurationException e) {
    throw new RuntimeException("Parsing XML failed: " + e + ", xml: "+ xml,e);
  }
}
 

@Override public void actionPerformed(ActionEvent e){
  if (transformer == null) {
    return;
  }
  JTextComponent target=getTextComponent(e);
  try {
    SyntaxDocument sdoc=ActionUtils.getSyntaxDocument(target);
    StringWriter out=new StringWriter(sdoc.getLength());
    StringReader reader=new StringReader(target.getText());
    InputSource src=new InputSource(reader);
    Document doc=getDocBuilder().parse(src);
    getTransformer().transform(new DOMSource(doc),new StreamResult(out));
    target.setText(out.toString());
  }
 catch (  SAXParseException ex) {
    showErrorMessage(target,String.format("XML error: %s\nat(%d, %d)",ex.getMessage(),ex.getLineNumber(),ex.getColumnNumber()));
    ActionUtils.setCaretPosition(target,ex.getLineNumber(),ex.getColumnNumber() - 1);
  }
catch (  TransformerException ex) {
    showErrorMessage(target,ex.getMessageAndLocation());
  }
catch (  SAXException ex) {
    showErrorMessage(target,ex.getLocalizedMessage());
  }
catch (  IOException ex) {
    showErrorMessage(target,ex.getLocalizedMessage());
  }
}
 

/** 
 * Gets a WSDL Definition (WSDL4J API) from the given WSDL file.
 * @param filename Absolute path of the WSDL file.
 * @param searchCache Searches the cache for Definition. If found returns cached Definition if this flag is set to true.
 * @param toCache If set to true put the the created Definition object in the cache for future lookups.
 * @throws IOException Encapsulates WSDLException, FileNotFoundException
 * @see #getWsdlDefinition(String)
 */
public static Definition getWsdlDefinition(String filename,boolean searchCache,boolean toCache) throws IOException {
  File wsdl=new File(filename);
  Definition definition=fParsedDefinitions.get(filename);
  if (searchCache && definition != null) {
    return definition;
  }
  try {
    WSDLReader reader=WSDLFactory.newInstance().newWSDLReader();
    InputSource source=new InputSource(new FileInputStream(wsdl));
    definition=reader.readWSDL(filename,source);
  }
 catch (  WSDLException e) {
    throw new IOException("Error while reading definition from WSDL file \"" + wsdl.getAbsolutePath() + "\".",e);
  }
catch (  FileNotFoundException e) {
    throw new IOException(e);
  }
  if (toCache) {
    fParsedDefinitions.put(filename,definition);
  }
  return definition;
}
 

private synchronized String doDescribe(Reader contents) throws IOException {
  try {
    InputSource source=new InputSource(contents);
    parser=new RootElementParser();
    parser.parse(source);
  }
 catch (  AcceptedException e) {
    return e.acceptedRootElement;
  }
catch (  RejectedException e) {
    return null;
  }
catch (  Exception e) {
    return null;
  }
 finally {
    parser=null;
  }
  return null;
}
 

/** 
 * @see cascading.operation.Function#operate(cascading.flow.FlowProcess,cascading.operation.FunctionCall) 
 */
public void operate(FlowProcess flowProcess,FunctionCall functionCall){
  try {
    StringWriter writer=new StringWriter();
    XMLWriter xmlWriter=new XMLWriter(writer);
    xmlWriter.setPrefix(getSchema().getURI(),"");
    xmlWriter.setOutputProperty(XMLWriter.OMIT_XML_DECLARATION,"yes");
    InputSource source=new InputSource(new StringReader((String)functionCall.getArguments().getObject(0)));
    getParser().setContentHandler(xmlWriter);
    getParser().parse(source);
    functionCall.getOutputCollector().add(new Tuple(writer.getBuffer().toString()));
  }
 catch (  SAXNotRecognizedException exception) {
    LOG.warn("ignoring TagSoup exception",exception);
  }
catch (  SAXNotSupportedException exception) {
    LOG.warn("ignoring TagSoup exception",exception);
  }
catch (  IOException exception) {
    LOG.warn("ignoring TagSoup exception",exception);
  }
catch (  SAXException exception) {
    LOG.warn("ignoring TagSoup exception",exception);
  }
}
 

public void fromXml(String xml) throws Exception {
  InputSource is=new InputSource(new StringReader(xml));
  Document doc=docBuilder.parse(is);
  Element root=doc.getDocumentElement();
  setRecordType(root.getTagName());
  long timestamp=Long.parseLong(root.getAttribute("ts"));
  setTimestamp(timestamp);
  NodeList children=root.getChildNodes();
  for (int i=0; i < children.getLength(); i++) {
    if (!children.item(i).getNodeName().equals("Metrics")) {
      continue;
    }
    NamedNodeMap attrs=children.item(i).getAttributes();
    if (attrs == null) {
      continue;
    }
    GenericChukwaMetrics metrics=new GenericChukwaMetrics();
    for (int a=0; a < attrs.getLength(); a++) {
      Attr attr=(Attr)attrs.item(a);
      String name=attr.getName();
      String value=attr.getValue();
      if (name.equals("key")) {
        metrics.setKey(value);
      }
 else {
        metrics.put(name,value);
      }
    }
    addMetrics(metrics);
  }
}
 

private InputSource getXmlSource(){
  if (xmlSource == null) {
    xmlSource=new InputSource();
  }
  return xmlSource;
}
 

private static Document parse(final String xml) throws MicrosoftAzureException {
  try {
    DocumentBuilder documentBuilder=createDocumentBuilder();
    Document xmlDoc=documentBuilder.parse(new InputSource(new StringReader(xml)));
    xmlDoc.normalizeDocument();
    return xmlDoc;
  }
 catch (  SAXException e) {
    throw new MicrosoftAzureException("Failed to parse XML Response from server. Response was: " + xml + ", Error was: "+ e.getMessage(),e);
  }
catch (  IOException e) {
    throw new MicrosoftAzureException("Failed to parse XML Response from server. Response was: " + xml + ", Error was: "+ e.getMessage(),e);
  }
}
 

/** 
 * Loads an instance of <code>Document</code> that contains the  classnames.xml file.
 * @return                          a <code>Document</code> object containing the classnames.xml file.
 * @since                           1.0
 */
private static Document getClassnamesXml(){
  File classnamesXmlFile=new File(classnamesXmlPath);
  if (!classnamesXmlFile.exists() || !classnamesXmlFile.isFile()) {
    return null;
  }
  DocumentBuilder db;
  try {
    db=DocumentBuilderFactory.newInstance().newDocumentBuilder();
    InputSource is=new InputSource(classnamesXmlFile.toURI().toURL().openStream());
    Document classnamesXmlDocument=db.parse(is);
    return classnamesXmlDocument;
  }
 catch (  Exception ex) {
    Logger.getLogger(ExtensionsLoader.class.getName()).log(Level.INFO,null,ex);
    return null;
  }
}
 

private static Object parsePlist(InputStream in){
  try {
    SAXParserFactory factory=SAXParserFactory.newInstance();
    SAXParser parser=factory.newSAXParser();
    PlistParser handler=new PlistParser();
    BufferedReader reader=new BufferedReader(new InputStreamReader(in),8192);
    parser.parse(new InputSource(reader),handler);
    return handler.rootDict;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

public InputSource resolveEntity(String publicId,String systemId) throws IOException {
  File entityFile=new File(root,systemId.substring("file://".length(),systemId.length()));
  APP.info("Chargement de l'entit de systemeId=" + systemId + "  partir du fichier "+ entityFile+ " ");
  if (!entityFile.exists()) {
    throw new IllegalArgumentException("Fichier introuvable : " + entityFile);
  }
  return new InputSource(new FileInputStream(entityFile));
}
 

/** 
 * convert
 * @param soapMessage
 * @param wsigService
 * @param operationName
 * @return
 * @throws Exception
 */
public Object convert(Message soapRequest,WSIGService wsigService,String operationName) throws Exception {
  Object actionObj=null;
  String soapMessage=soapRequest.getSOAPPartAsString();
  if (xr == null) {
    throw new Exception("Parser not initialized");
  }
  onto=wsigService.getOnto();
  xr.parse(new InputSource(new StringReader(soapMessage)));
  Vector<ParameterInfo> params=getParameters();
  ActionBuilder actionBuilder=wsigService.getActionBuilder(operationName);
  actionObj=actionBuilder.getAgentAction(params);
  return actionObj;
}
 

public ErrorReport getErrorReport(Reader xml){
  ErrorReport errorReport=null;
  try {
    InputSource inputSource=new InputSource(xml);
    ClassLoader cl=ErrorReport.class.getClassLoader();
    if (cl == null) {
      LOGGER.error("couldn't create class loader.");
    }
    JAXBContext context=JAXBContext.newInstance(PACKAGE,cl);
    Unmarshaller unmarshaller=context.createUnmarshaller();
    unmarshaller.setEventHandler(new ValidationEventHandler(){
      @SuppressWarnings("synthetic-access") public boolean handleEvent(      ValidationEvent ve){
        if (ve.getSeverity() != ValidationEvent.WARNING) {
          ValidationEventLocator vel=ve.getLocator();
          LOGGER.warn("Line:Col[" + vel.getLineNumber() + ":"+ vel.getColumnNumber()+ "]:"+ ve.getMessage());
        }
        return true;
      }
    }
);
    errorReport=(ErrorReport)unmarshaller.unmarshal(inputSource);
  }
 catch (  JAXBException e) {
    LOGGER.error("Error parsing file",e);
    throw new RulesException("Failed reading file");
  }
  return errorReport;
}
 

public InputSource resolveEntity(String publicID,String systemID) throws SAXException, IOException {
  if (publicID == null || systemID == null) {
    return null;
  }
  for (int i=0; i < ThemesConstants.DOCUMENT_PUBLIC_IDS.size(); i++) {
    if (publicID.indexOf(ThemesConstants.DOCUMENT_PUBLIC_IDS.get(i)) != -1 && systemID.indexOf(ThemesConstants.DOCUMENT_SYSTEM_IDS.get(i)) != -1) {
      return new InputSource(new ByteArrayInputStream(ThemesConstants.DOCUMENT_HEADER.getBytes()));
    }
  }
  return null;
}
 

/** 
 * <p>Parse the specified JavaServer Faces configuration resource, causing the appropriate JSF artifacts to be registered with the mock object hierarchy.</p>
 * @param url <code>URL</code> of the configuration resource to parse
 * @exception IOException if an input/output error occurs
 * @exception SAXException if a parsing error occurs
 */
public void parse(URL url) throws IOException, SAXException {
  Digester digester=digester();
  ApplicationFactory factory=(ApplicationFactory)FactoryFinder.getFactory(FactoryFinder.APPLICATION_FACTORY);
  Application application=factory.getApplication();
  digester.push(application);
  try {
    digester.parse(new InputSource(url.openStream()));
  }
  finally {
    digester.clear();
  }
}
 

public static String getXPathValue(IFile file,String xPath) throws Exception {
  DocumentBuilderFactory docFactory=DocumentBuilderFactory.newInstance();
  docFactory.setNamespaceAware(false);
  docFactory.setValidating(false);
  DocumentBuilder builder=docFactory.newDocumentBuilder();
  XPathFactory factory=XPathFactory.newInstance();
  XPath xpath=factory.newXPath();
  final XPathExpression exp=xpath.compile(xPath);
  Document doc=builder.parse(new InputSource(file.getContents()));
  final NodeList nodeList=(NodeList)exp.evaluate(doc,XPathConstants.NODESET);
  return XMLUtils.getNodeValue(nodeList);
}
 

/** 
 * Loads the contents of file into the model
 * @param aFile the file to extract events from
 * @return the number of events loaded
 * @throws SAXException if an error occurs
 * @throws IOException if an error occurs
 */
private int loadFile(String aFile) throws SAXException, IOException {
synchronized (mParser) {
    final StringBuffer buf=new StringBuffer();
    buf.append("<?xml version=\"1.0\" standalone=\"yes\"?>\n");
    buf.append("<!DOCTYPE log4j:eventSet ");
    buf.append("[<!ENTITY data SYSTEM \"file:///");
    buf.append(aFile);
    buf.append("\">]>\n");
    buf.append("<log4j:eventSet xmlns:log4j=\"Claira\">\n");
    buf.append("&data;\n");
    buf.append("</log4j:eventSet>\n");
    final InputSource is=new InputSource(new StringReader(buf.toString()));
    mParser.parse(is);
    return mHandler.getNumEvents();
  }
}
 

@Test public void testConnector() throws Exception {
  final String dtdFile="src/test/resources/dtd/connector_1_0.dtd";
  final InputSource in=new InputSource(new FileReader(dtdFile));
  final TestDtdEventListener dtdEventListener=new TestDtdEventListener("j2ee","org.jboss.shrinkwrap.descriptor.test.api.connector10","org.jboss.shrinkwrap.descriptor.test.impl.connector10",dtdFile);
  final DTDParser parser=new DTDParser();
  parser.setDtdHandler(dtdEventListener);
  parser.parse(in);
  final Metadata metadata=dtdEventListener.getMetadata();
  MetadataDescriptor metadataDescriptor=new MetadataDescriptor("ConnectorDescriptor");
  metadataDescriptor.setRootElementName("connector");
  metadataDescriptor.setRootElementType("j2ee:connector");
  metadataDescriptor.setSchemaName(dtdFile);
  metadataDescriptor.setPackageApi("org.jboss.shrinkwrap.descriptor.test.api.connector10");
  metadataDescriptor.setPackageImpl("org.jboss.shrinkwrap.descriptor.test.impl.connector10");
  metadataDescriptor.setNamespace("j2ee");
  metadata.getMetadataDescriptorList().add(metadataDescriptor);
  metadata.preResolveDataTypes();
  new MetadataUtil().log(metadata);
  new DomWriter().write(metadata,"/tmp/connector_1_0.xml");
}
 

public void parse(URL url) throws IOException, SAXException {
  InputStream is=null;
  try {
    is=url.openStream();
    reader.setContentHandler(this);
    reader.parse(new InputSource(is));
  }
  finally {
    Closeables.closeQuietly(is);
  }
}
 

public InputSource resolveEntity(String publicId,String systemId){
  log.debug("Trying to resolve XML entity with public ID [{}] and system ID [{}]",publicId,systemId);
  if (systemId != null && systemId.indexOf(DozerConstants.XSD_NAME) > systemId.lastIndexOf("/")) {
    String fileName=systemId.substring(systemId.indexOf(DozerConstants.XSD_NAME));
    log.debug("Trying to locate [{}] in classpath",fileName);
    try {
      DozerClassLoader classLoader=BeanContainer.getInstance().getClassLoader();
      URL url=classLoader.loadResource(fileName);
      InputStream stream=url.openStream();
      InputSource source=new InputSource(stream);
      source.setPublicId(publicId);
      source.setSystemId(systemId);
      log.debug("Found beanmapping XML Schema [{}] in classpath",systemId);
      return source;
    }
 catch (    Exception ex) {
      log.error("Could not resolve beanmapping XML Schema [" + systemId + "]: not found in classpath",ex);
    }
  }
  return null;
}
 

@Override public boolean parse(String input){
  try {
    mError=false;
    mErrorText=null;
    ByteArrayInputStream bais=new ByteArrayInputStream(input.getBytes());
    InputSource is=new InputSource();
    is.setByteStream(bais);
    SAXParserFactory spf=SAXParserFactory.newInstance();
    spf.setValidating(false);
    SAXParser sp=spf.newSAXParser();
    XMLReader xr=sp.getXMLReader();
    xr.setContentHandler(mHandler);
    xr.parse(is);
    return true;
  }
 catch (  ParserConfigurationException e) {
    Log.e(DreamDroid.LOG_TAG,e.toString());
    mError=true;
    mErrorText=e.toString();
    e.printStackTrace();
  }
catch (  SAXException e) {
    Log.e(DreamDroid.LOG_TAG,e.toString());
    mError=true;
    mErrorText=e.toString();
    e.printStackTrace();
  }
catch (  IOException e) {
    Log.e(DreamDroid.LOG_TAG,e.toString());
    mError=true;
    mErrorText=e.toString();
    e.printStackTrace();
  }
  return false;
}
 

private void parseXml(byte[] s) throws MojoFailureException {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  try {
    DocumentBuilder db=dbf.newDocumentBuilder();
    Document dom=db.parse(new InputSource(new ByteArrayInputStream(s)));
    NodeList nl=dom.getDocumentElement().getChildNodes();
    for (int i=0; i < nl.getLength(); i++) {
      Object uel=nl.item(i);
      if (uel instanceof Element) {
        Element el=(Element)uel;
        String nodeName=el.getNodeName();
        if (nodeName.equals("id"))         id=el.getTextContent();
      }
    }
  }
 catch (  ParserConfigurationException e) {
    throwParseFail(file,e);
  }
catch (  SAXException e) {
    throwParseFail(file,e);
  }
catch (  IOException e) {
    throwParseFail(file,e);
  }
}
 

@Override public void run(){
  weatherZip=LocationMonitor.getZip();
  URL url;
  try {
    String tmpStr=null;
    String cityParamString=weatherZip;
    Log.d(TAG,"cityParamString: " + cityParamString);
    String queryString="http://www.google.com/ig/api?weather=" + cityParamString;
    url=new URL(queryString.replace(" ","%20"));
    SAXParserFactory spf=SAXParserFactory.newInstance();
    SAXParser sp=spf.newSAXParser();
    XMLReader xr=sp.getXMLReader();
    gwh=new GoogleWeatherHandler();
    xr.setContentHandler(gwh);
    xr.parse(new InputSource(url.openStream()));
    ws=gwh.getWeatherSet();
    if (ws == null)     return;
    WeatherCurrentCondition wcc=ws.getWeatherCurrentCondition();
    if (wcc != null) {
      weatherTemp=null;
      Integer weatherTempInt=wcc.getTempFahrenheit();
      if (weatherTempInt != null) {
        weatherTemp=weatherTempInt;
      }
      weatherCond=wcc.getCondition();
      weatherHumid=wcc.getHumidity();
      weatherWindCond=wcc.getWindCondition();
      weatherHazard=calcHazard();
    }
  }
 catch (  Exception e) {
    Log.e(TAG,"WeatherQueryError",e);
  }
}
 

public ArrayList<Flavor> createList(boolean detail,Context context){
  CustomHttpClient httpclient=new CustomHttpClient(context);
  HttpGet get=new HttpGet(Account.getAccount().getServerUrl() + "/flavors/detail.xml?now=cache_time2");
  ArrayList<Flavor> flavors=new ArrayList<Flavor>();
  get.addHeader("X-Auth-Token",Account.getAccount().getAuthToken());
  try {
    HttpResponse resp=httpclient.execute(get);
    BasicResponseHandler responseHandler=new BasicResponseHandler();
    String body=responseHandler.handleResponse(resp);
    if (resp.getStatusLine().getStatusCode() == 200 || resp.getStatusLine().getStatusCode() == 203) {
      FlavorsXMLParser flavorsXMLParser=new FlavorsXMLParser();
      SAXParser saxParser=SAXParserFactory.newInstance().newSAXParser();
      XMLReader xmlReader=saxParser.getXMLReader();
      xmlReader.setContentHandler(flavorsXMLParser);
      xmlReader.parse(new InputSource(new StringReader(body)));
      flavors=flavorsXMLParser.getFlavors();
    }
  }
 catch (  ClientProtocolException cpe) {
  }
catch (  IOException e) {
  }
catch (  ParserConfigurationException e) {
  }
catch (  SAXException e) {
  }
catch (  FactoryConfigurationError e) {
  }
  return flavors;
}
 

/** 
 * {@inheritDoc}
 */
@Override protected void doValidate(){
  if (this._id == null || "".equals(this._id)) {
    throw new Ant4EclipseException(PdeExceptionCode.ANT_ATTRIBUTE_NOT_SET,"id");
  }
  if (this._targetFile != null) {
    if (!this._targetFile.exists()) {
      throw new Ant4EclipseException(PdeExceptionCode.TARGET_FILE_NOT_FOUND,this._targetFile.toString());
    }
    try {
      XMLReader reader=XMLReaderFactory.createXMLReader();
      reader.setContentHandler(new TargetPlattformContentHandler(this._targetFile,this));
      FileInputStream in=new FileInputStream(this._targetFile);
      try {
        reader.parse(new InputSource(new InputStreamReader(in,"UTF-8")));
      }
  finally {
        in.close();
      }
    }
 catch (    SAXException e) {
      Ant4EclipseException exeption=new Ant4EclipseException(PdeExceptionCode.TARGET_PARSING_FAILED,this._targetFile.toString(),e.toString());
      exeption.initCause(e);
      throw exeption;
    }
catch (    IOException e) {
      Ant4EclipseException exeption=new Ant4EclipseException(PdeExceptionCode.TARGET_PARSING_FAILED,this._targetFile.toString(),e.toString());
      exeption.initCause(e);
      throw exeption;
    }
  }
  if (this._targetPlatformDefinition.getLocations().length == 0) {
    A4ELogging.warn("Target definition with id %s does not contain any locations!",this._id);
  }
  TargetPlatformRegistry targetPlatformRegistry=ServiceRegistryAccess.instance().getService(TargetPlatformRegistry.class);
  targetPlatformRegistry.addTargetPlatformDefinition(this._id,this._targetPlatformDefinition);
}
 

private Document parse() throws IOException, SAXException, TransformerException {
  final DOMParser parser=new DOMParser(){
    private QName currentQName;
    private Augmentations currentAugmentations;
    @Override protected Element createElementNode(    QName qName){
      final Element created=super.createElementNode(qName);
      if (qName.equals(currentQName) && currentAugmentations != null) {
        final ElementLocation elementLocation=createElementLocation(currentAugmentations.getItem(AUGMENTATIONS_FEATURE));
        created.setUserData(ELEMENT_LOCATION,elementLocation,null);
      }
      return created;
    }
    @Override public void startElement(    QName qName,    XMLAttributes xmlAttributes,    Augmentations augmentations) throws XNIException {
      super.startElement(qName,xmlAttributes,augmentations);
      currentQName=qName;
      currentAugmentations=augmentations;
    }
    private ElementLocation createElementLocation(    Object obj){
      if (obj == null)       return null;
      String pattern=null;
      try {
        pattern=obj.toString();
        if ("synthesized".equals(pattern))         return null;
        final String[] parts=pattern.split(":");
        return new ElementLocation(Integer.parseInt(parts[0]),Integer.parseInt(parts[1]),Integer.parseInt(parts[3]),Integer.parseInt(parts[4]));
      }
 catch (      Exception e) {
        logger.warn(String.format("Unexpected string format for given augmentation: [%s]",pattern),e);
        return null;
      }
    }
  }
;
  parser.setFeature("http://xml.org/sax/features/namespaces",false);
  parser.setFeature("http://cyberneko.org/html/features/scanner/script/strip-cdata-delims",true);
  parser.setFeature(AUGMENTATIONS_FEATURE,true);
  if (this.encoding != null)   parser.setProperty("http://cyberneko.org/html/properties/default-encoding",this.encoding);
  parser.parse(new InputSource(new SpanCloserInputStream(input)));
  return parser.getDocument();
}
 

public void run(){
  try {
    reader=XMLReaderFactory.createXMLReader();
    reader.setFeature(XML_VALIDATION_FEATURE,true);
    reader.setFeature(XML_SCHEMA_FEATURE,true);
    reader.setFeature(XML_SCHEMA_FULL_CHECKING_FEATURE,true);
    reader.setContentHandler(new DefaultHandler());
    reader.setErrorHandler(new PassingSAXErrorHandler());
    reader.parse(new InputSource(in));
  }
 catch (  Exception e) {
    validationMessage=e.getMessage();
    throw new IllegalStateException(e);
  }
 finally {
    latch.countDown();
  }
}
 

@Override public void parseAsXml(InputStream inputStream,IEntity destEntity) throws ServiceException {
  try {
    SAXParserFactory spf=SAXParserFactory.newInstance();
    SAXParser sp=spf.newSAXParser();
    XMLReader xr=sp.getXMLReader();
    xr.setContentHandler(new XmlParser(destEntity));
    xr.parse(new InputSource(inputStream));
  }
 catch (  ParserConfigurationException e) {
    log.error("An error occurred while instantiating XML Parser",e);
    throw new ServiceException(ServiceException.GENERIC_ERROR,e.getMessage());
  }
catch (  SAXException e) {
    log.error("An error occurred while instantiating XML Parser",e);
    throw new ServiceException(ServiceException.GENERIC_ERROR,e.getMessage());
  }
catch (  IllegalStateException e) {
    log.error("An error occurred while parsing response",e);
    throw new ServiceException(ServiceException.GENERIC_ERROR,e.getMessage());
  }
catch (  IOException e) {
    log.error("An error occurred while parsing response",e);
    throw new ServiceException(ServiceException.GENERIC_ERROR,e.getMessage());
  }
}
 

private void processEntry(final ZipInputStream zis,final ZipEntry ze,final ContentHandlerFactory handlerFactory){
  ContentHandler handler=handlerFactory.createContentHandler();
  try {
    boolean singleInputDocument=inRepresentation == SINGLE_XML;
    if (inRepresentation == BYTECODE) {
      ClassReader cr=new ClassReader(readEntry(zis,ze));
      cr.accept(new SAXClassAdapter(handler,singleInputDocument),0);
    }
 else {
      XMLReader reader=XMLReaderFactory.createXMLReader();
      reader.setContentHandler(handler);
      reader.parse(new InputSource(singleInputDocument ? (InputStream)new ProtectedInputStream(zis) : new ByteArrayInputStream(readEntry(zis,ze))));
    }
  }
 catch (  Exception ex) {
    update(ze.getName(),0);
    update(ex,0);
  }
}
 

private boolean isTestsFailed(List<File> surefireReports){
  XPathFactory factory=XPathFactory.newInstance();
  XPath path=factory.newXPath();
  for (  File report : surefireReports) {
    FileInputStream stream=null;
    try {
      stream=new FileInputStream(report);
      Object evaluate=path.evaluate("/testsuite/@failures",new InputSource(stream),XPathConstants.STRING);
      if (evaluate != null && StringUtils.isNotBlank(evaluate.toString()) && StringUtils.isNumeric(evaluate.toString())) {
        int testsFailed=Integer.parseInt(evaluate.toString());
        return testsFailed != 0;
      }
    }
 catch (    FileNotFoundException e) {
      logger.error("File '" + report.getAbsolutePath() + "' does not exist.");
    }
catch (    XPathExpressionException e) {
      logger.error("Expression /testsuite/@failures is invalid.");
    }
 finally {
      Closeables.closeQuietly(stream);
    }
  }
  return false;
}
 

/** 
 * {@inheritDoc}
 */
public Document readDocument(String originalText,String corpusName){
  inAbstract=false;
  inTitle=false;
  inPMID=false;
  inTitle=false;
  labels.clear();
  b.setLength(0);
  try {
    saxParser.parse(new InputSource(new StringReader(originalText)),this);
  }
 catch (  SAXException se) {
    throw new RuntimeException(se);
  }
catch (  IOException ioe) {
    throw new IOError(ioe);
  }
  return new SimpleDocument(corpusName,docText,originalText,key,id,title,labels);
}
 

/** 
 * Parses the content of a translated XLIFF file and creates a SoyMsgBundle.
 * @param xliffContent The XLIFF content to parse.
 * @return The resulting SoyMsgBundle.
 * @throws SAXException If there's an error parsing the data.
 * @throws SoyMsgException If there's an error in parsing the data.
 */
static SoyMsgBundle parseXliffTargetMsgs(String xliffContent) throws SAXException, SoyMsgException {
  SAXParserFactory saxParserFactory=SAXParserFactory.newInstance();
  SAXParser saxParser;
  try {
    saxParser=saxParserFactory.newSAXParser();
  }
 catch (  ParserConfigurationException pce) {
    throw new AssertionError("Could not get SAX parser for XML.");
  }
  XliffSaxHandler xliffSaxHandler=new XliffSaxHandler();
  try {
    saxParser.parse(new InputSource(new StringReader(xliffContent)),xliffSaxHandler);
  }
 catch (  IOException e) {
    throw new AssertionError("Should not fail in reading a string.");
  }
  return new SoyMsgBundleImpl(xliffSaxHandler.getTargetLocaleString(),xliffSaxHandler.getMsgs());
}
 

public ParallelChunk parseString(String xml){
  resultChunk=null;
  try {
    sp.parse(new InputSource(new StringReader(xml)),this);
  }
 catch (  final SAXException se) {
    resultChunk=null;
    se.printStackTrace();
    throw new RuntimeException("SaxE: " + se + "\n"+ xml);
  }
catch (  final IOException ie) {
    resultChunk=null;
    ie.printStackTrace();
    throw new RuntimeException("ioe: " + ie);
  }
  return resultChunk;
}
 

public Point[] getPoints(String xml) throws Exception {
  try {
    DocumentBuilder db=DocumentBuilderFactory.newInstance().newDocumentBuilder();
    Document doc=db.parse(new InputSource(new StringReader(xml)));
    XPath xpath=XPathFactory.newInstance().newXPath();
    XPathExpression expr=xpath.compile("//polygon[@id='collide']/@points");
    String[] pointsAttr=((String)expr.evaluate(doc,XPathConstants.STRING)).split("\\p{Space}");
    Point[] points=new Point[pointsAttr.length];
    for (int i=0; i < pointsAttr.length; ++i) {
      String[] coordinates=pointsAttr[i].split(",");
      points[i]=new Point(Double.valueOf(coordinates[0]),Double.valueOf(coordinates[1]));
    }
    return points;
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
  return null;
}
 

private static void filterProjectXML(FileObject fo,ZipInputStream str,String name) throws IOException {
  try {
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    FileUtil.copy(str,baos);
    Document doc=XMLUtil.parse(new InputSource(new ByteArrayInputStream(baos.toByteArray())),false,false,null,null);
    NodeList nl=doc.getDocumentElement().getElementsByTagName("name");
    if (nl != null) {
      for (int i=0; i < nl.getLength(); i++) {
        Element el=(Element)nl.item(i);
        if (el.getParentNode() != null && "data".equals(el.getParentNode().getNodeName())) {
          NodeList nl2=el.getChildNodes();
          if (nl2.getLength() > 0) {
            nl2.item(0).setNodeValue(name);
          }
          break;
        }
      }
    }
    OutputStream out=fo.getOutputStream();
    try {
      XMLUtil.write(doc,out,"UTF-8");
    }
  finally {
      out.close();
    }
  }
 catch (  Exception ex) {
    Exceptions.printStackTrace(ex);
    writeFile(str,fo);
  }
}
 

private ArrayList<Forecast> buildForecasts(String raw) throws Exception {
  ArrayList<Forecast> forecasts=new ArrayList<Forecast>();
  DocumentBuilder builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document doc=builder.parse(new InputSource(new StringReader(raw)));
  NodeList times=doc.getElementsByTagName("start-valid-time");
  for (int i=0; i < times.getLength(); i++) {
    Element time=(Element)times.item(i);
    Forecast forecast=new Forecast();
    forecasts.add(forecast);
    forecast.setTime(time.getFirstChild().getNodeValue());
  }
  NodeList temps=doc.getElementsByTagName("value");
  for (int i=0; i < temps.getLength(); i++) {
    Element temp=(Element)temps.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setTemp(new Integer(temp.getFirstChild().getNodeValue()));
  }
  NodeList icons=doc.getElementsByTagName("icon-link");
  for (int i=0; i < icons.getLength(); i++) {
    Element icon=(Element)icons.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setIcon(icon.getFirstChild().getNodeValue());
  }
  return (forecasts);
}
 

void buildForecasts(String raw) throws Exception {
  DocumentBuilder builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document doc=builder.parse(new InputSource(new StringReader(raw)));
  NodeList times=doc.getElementsByTagName("start-valid-time");
  for (int i=0; i < times.getLength(); i++) {
    Element time=(Element)times.item(i);
    Forecast forecast=new Forecast();
    forecasts.add(forecast);
    forecast.setTime(time.getFirstChild().getNodeValue());
  }
  NodeList temps=doc.getElementsByTagName("value");
  for (int i=0; i < temps.getLength(); i++) {
    Element temp=(Element)temps.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setTemp(new Integer(temp.getFirstChild().getNodeValue()));
  }
  NodeList icons=doc.getElementsByTagName("icon-link");
  for (int i=0; i < icons.getLength(); i++) {
    Element icon=(Element)icons.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setIcon(icon.getFirstChild().getNodeValue());
  }
}
 

private ArrayList<Forecast> buildForecasts(String raw) throws Exception {
  ArrayList<Forecast> forecasts=new ArrayList<Forecast>();
  DocumentBuilder builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document doc=builder.parse(new InputSource(new StringReader(raw)));
  NodeList times=doc.getElementsByTagName("start-valid-time");
  for (int i=0; i < times.getLength(); i++) {
    Element time=(Element)times.item(i);
    Forecast forecast=new Forecast();
    forecasts.add(forecast);
    forecast.setTime(time.getFirstChild().getNodeValue());
  }
  NodeList temps=doc.getElementsByTagName("value");
  for (int i=0; i < temps.getLength(); i++) {
    Element temp=(Element)temps.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setTemp(new Integer(temp.getFirstChild().getNodeValue()));
  }
  NodeList icons=doc.getElementsByTagName("icon-link");
  for (int i=0; i < icons.getLength(); i++) {
    Element icon=(Element)icons.item(i);
    Forecast forecast=forecasts.get(i);
    forecast.setIcon(icon.getFirstChild().getNodeValue());
  }
  return (forecasts);
}
 

@Deprecated protected List<Tag> fetchTagsIndexXML(String url_format,int page,String name,int limit){
  TreeSet<Tag> ret=new TreeSet<Tag>(new Tag.CompareById());
  String keywords[]=new HashSet<String>(Arrays.asList(name.split("\\+"))).toArray(new String[]{});
  for (  String keyword : keywords) {
    keyword=keyword.trim().replace(' ','_');
    try {
      URL fetchUrl=new URL(String.format(url_format,page,keyword,limit));
      D.Log.v("DanbooruStyleAPI::fetchTagsIndexXML(): fetching %s",fetchUrl);
      DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
      DocumentBuilder db=dbf.newDocumentBuilder();
      Document doc=db.parse(new InputSource(fetchUrl.openStream()));
      doc.getDocumentElement().normalize();
      NodeList nodes=doc.getElementsByTagName("tag");
      int length=nodes.getLength();
      for (int i=0; i < length; ++i) {
        ret.add(new Tag((Element)nodes.item(i)));
        if (isCanceled())         return null;
      }
    }
 catch (    UnsupportedEncodingException e) {
      D.Log.wtf(e);
    }
catch (    IOException e) {
      D.Log.wtf(e);
    }
catch (    SAXException e) {
      D.Log.wtf(e);
    }
catch (    ParserConfigurationException e) {
      D.Log.wtf(e);
    }
  }
  return Arrays.asList(ret.toArray(new Tag[]{}));
}
 

/** 
 * @return
 */
public boolean initialize(){
  if (logger.isTraceEnabled()) {
    logger.trace("initialize() - entry");
  }
  characterFound=false;
  elementCount=0;
  buffer=new StringBuffer();
  try {
    xmlReader=saxParser.getXMLReader();
    xmlReader.setContentHandler(this);
    xmlReader.setErrorHandler(this);
    xmlReader.setFeature("http://xml.org/sax/features/validation",false);
    input=new InputSource(new ReaderWrapper(this.reader));
  }
 catch (  SAXNotRecognizedException e) {
    return false;
  }
catch (  SAXNotSupportedException e) {
    return false;
  }
catch (  SAXException e) {
    return false;
  }
  if (logger.isTraceEnabled()) {
    logger.trace("initialize() - exit");
  }
  return true;
}
 

public String parseXML(ByteArrayBuffer xmlData){
  if (xmlData != null && xmlData.length() > 0) {
    try {
      ByteArrayInputStream bais=new ByteArrayInputStream(xmlData.buffer(),0,xmlData.length());
      SAXParserFactory spf=SAXParserFactory.newInstance();
      SAXParser sp=spf.newSAXParser();
      XMLReader xr=sp.getXMLReader();
      CustomDataXmlHandler triggerHandler=new CustomDataXmlHandler();
      xr.setContentHandler(triggerHandler);
      xr.parse(new InputSource(bais));
      String customData=triggerHandler.getCustomData();
      return customData;
    }
 catch (    ParserConfigurationException e) {
    }
catch (    SAXException e) {
    }
catch (    IOException e) {
    }
  }
  return null;
}
 

protected boolean evaluate(InputSource inputSource){
  try {
    DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(true);
    DocumentBuilder dbuilder=factory.newDocumentBuilder();
    Document doc=dbuilder.parse(inputSource);
    CachedXPathAPI cachedXPathAPI=new CachedXPathAPI();
    XObject result=cachedXPathAPI.eval(doc,xpath);
    if (result.bool())     return true;
 else {
      NodeIterator iterator=cachedXPathAPI.selectNodeIterator(doc,xpath);
      return (iterator.nextNode() != null);
    }
  }
 catch (  Throwable e) {
    return false;
  }
}
 

private void validateXML(String xml) throws Exception {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  dbf.setValidating(true);
  dbf.setNamespaceAware(true);
  dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage","http://www.w3.org/2001/XMLSchema");
  DocumentBuilder db=dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorHandler(){
    @Override public void warning(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    @Override public void fatalError(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    @Override public void error(    SAXParseException exception) throws SAXException {
      throw exception;
    }
  }
);
  db.setEntityResolver(new EntityResolver(){
    @Override public InputSource resolveEntity(    String publicId,    String systemId) throws SAXException, IOException {
      if ("http://jboss.org/schema/arquillian/arquillian_1_0.xsd".equals(systemId)) {
        return new InputSource(this.getClass().getClassLoader().getResourceAsStream("arquillian_1_0.xsd"));
      }
      return null;
    }
  }
);
  db.parse(new ByteArrayInputStream(xml.getBytes()));
}
 

/** 
 * @param xmlFile
 * @return name of DTD file specified in the !DOCTYPE or null if not specified.
 */
public String resolveDtdLocation(final String xmlFile){
  final InputStream xmlStream=Thread.currentThread().getContextClassLoader().getResourceAsStream(xmlFile);
  try {
    final DocumentBuilder builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
    builder.setEntityResolver(new EntityResolver(){
      @Override public InputSource resolveEntity(      String publicId,      String systemId) throws SAXException, IOException {
        return new InputSource(new StringReader(""));
      }
    }
);
    final Document document=builder.parse(xmlStream);
    if (document.getDoctype() == null) {
      return null;
    }
    return document.getDoctype().getSystemId();
  }
 catch (  Exception e) {
    throw new RuntimeException("Unable to resolve dtd for " + xmlFile,e);
  }
}
 

/** 
 * Parse the given input source and return the root Element
 */
public static Element parse(InputSource source) throws IOException {
  try {
    return getDocumentBuilder().parse(source).getDocumentElement();
  }
 catch (  SAXException se) {
    throw new IOException(se.toString());
  }
 finally {
    InputStream is=source.getByteStream();
    if (is != null) {
      is.close();
    }
    Reader r=source.getCharacterStream();
    if (r != null) {
      r.close();
    }
  }
}
 

private void validate(InputStream src){
  ccr=null;
  try {
    SAXSource source=new SAXSource(new InputSource(src));
    validator.validate(source);
    Document xml=parseStreamSource(src,false);
    if (xml != null) {
      JAXBContext jc=JAXBContext.newInstance("org.astm.ccr");
      Unmarshaller um=jc.createUnmarshaller();
      ccr=(ContinuityOfCareRecord)um.unmarshal(xml);
    }
  }
 catch (  SAXException e) {
    logger.log(Level.SEVERE,"Not Valid CCR XML: " + e.getMessage());
  }
catch (  IOException e) {
    logger.log(Level.SEVERE,"Exception during validating",e);
    e.printStackTrace();
  }
catch (  JAXBException e) {
    logger.log(Level.SEVERE,"Exception during unmarshalling XML DOM",e);
    e.printStackTrace();
  }
}
 

private void GraphType(String resourceName){
  try {
    InputStream templateGraph=getClass().getResourceAsStream(resourceName);
    _template=new RrdGraphDefTemplate(new InputSource(templateGraph));
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

private static void load(ApplicationConfiguration applicationConfiguration,InputSource input,String[] environments,String[] implicitEnvironments){
  Document doc=readXML(input);
  Element rootElement=doc.getDocumentElement();
  if (rootElement.getNodeName().equals("stax-application") || rootElement.getNodeName().equals("stax-web-app") || rootElement.getNodeName().equals("cloudbees-web-app")) {
    AppConfigParser parser=new AppConfigParser();
    parser.load(applicationConfiguration,doc,environments,implicitEnvironments);
  }
}