Java Code Examples for org.w3c.dom.Document

public PubMedIdList importPubMedID(String StudyID) throws IOException {
  InputStream inOne=openUrl(PUBMED_API + "esearch.fcgi?db=pubmed&retmax=0&usehistory=y&term=" + StudyID+ "[Secondary%20Source%20ID]");
  String resultsUrl=getResultsUrl(inOne);
  InputStream inTwo=openUrl(PUBMED_API + resultsUrl);
  Document docTwo=parse(inTwo);
  return getIdList(docTwo);
}
 

public void readConnectionsXML() throws ParserConfigurationException, SAXException, IOException {
  DocumentBuilderFactory dbFactory=DocumentBuilderFactory.newInstance();
  DocumentBuilder dBuilder=dbFactory.newDocumentBuilder();
  Document doc=dBuilder.parse(getClass().getResourceAsStream("/got/resource/xml/connection.xml"));
  doc.getDocumentElement().normalize();
  NodeList nList=doc.getElementsByTagName("Connection");
  for (int temp=0; temp < nList.getLength(); temp++) {
    Node nNode=nList.item(temp);
    String t1=nNode.getAttributes().getNamedItem("t1").getNodeValue();
    String t2=nNode.getAttributes().getNamedItem("t2").getNodeValue();
    getConnTerritories().get(t1).add(t2);
    getConnTerritories().get(t2).add(t1);
  }
}
 

protected final void parseDocument(File f) throws Exception {
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  factory.setValidating(false);
  factory.setIgnoringComments(true);
  Document doc=factory.newDocumentBuilder().parse(f);
  for (Node start0=doc.getFirstChild(); start0 != null; start0=start0.getNextSibling()) {
    readData(start0);
  }
}
 

/** 
 * Instantiates a new xml dom.
 * @param is Raw XML.
 * @throws SAXException the SAX exception
 */
public XmlDom(InputStream is) throws SAXException {
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  DocumentBuilder builder;
  try {
    builder=factory.newDocumentBuilder();
    Document doc=builder.parse(is);
    this.root=(Element)doc.getDocumentElement();
  }
 catch (  ParserConfigurationException e) {
  }
catch (  IOException e) {
    throw new SAXException(e);
  }
}
 

public List load(InputStream ins) throws ParserConfigurationException, SAXException, IOException {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  DocumentBuilder db=dbf.newDocumentBuilder();
  Document doc=db.parse(ins);
  return loadConnectors(doc);
}
 

/** 
 * Returns the validated DOM and applies fixes on it if <i>applyFix</i> is set to <code>true</code>.
 * @param applyFix
 * @return a report containing the <i>HTML</i> DOM that has been validated and fixed if <i>applyFix</i>if <code>true</code>. The reports contains also information about the activated rules and the the detected issues.
 * @throws IOException
 * @throws org.apache.any23.validator.ValidatorException
 */
public DocumentReport getValidatedDOM(boolean applyFix) throws IOException, ValidatorException {
  final URI dURI;
  try {
    dURI=new URI(documentURI);
  }
 catch (  URISyntaxException urise) {
    throw new ValidatorException("Error while performing validation, invalid document URI.",urise);
  }
  Validator validator=new DefaultValidator();
  Document document=getDOM();
  return new DocumentReport(validator.validate(dURI,document,applyFix),document);
}
 

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 static List<String> extractServletNames(String descriptor) throws Exception {
  Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(descriptor.getBytes()));
  XPathExpression xPathExpression=XPathFactory.newInstance().newXPath().compile("/web-app/servlet/servlet-name");
  NodeList nodes=(NodeList)xPathExpression.evaluate(doc,XPathConstants.NODESET);
  List<String> servletNames=new ArrayList<String>();
  for (int i=0; i < nodes.getLength(); i++) {
    Node node=nodes.item(i);
    servletNames.add(node.getTextContent());
  }
  return servletNames;
}
 

/** 
 * Assert that the specified XPath Expression resolves to the specified values. <br/><br/> Assertions:<br/> "ExpectedValue count should match found Node count" <br/>  "XPath content should match expected value" <br/>
 * @param xml The XML to assert against
 * @param expression XPath expression to extract
 * @param expectedValue The Expected values found by expression
 * @throws Exception XML/XPath related parse exceptions
 */
public static void assertXPath(String xml,String expression,Object... expectedValue) throws Exception {
  Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(xml.getBytes()));
  XPathExpression xPathExpression=XPathFactory.newInstance().newXPath().compile(expression);
  NodeList nodes=(NodeList)xPathExpression.evaluate(doc,XPathConstants.NODESET);
  Assert.assertEquals("ExpectedValue count should match found Node count",expectedValue.length,nodes.getLength());
  for (int i=0; i < nodes.getLength(); i++) {
    Node node=nodes.item(i);
    Assert.assertEquals("XPath content should match expected value",String.valueOf(expectedValue[i]),node.getTextContent());
  }
}
 

private static List<String> extractServletNames(String descriptor) throws Exception {
  Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(descriptor.getBytes()));
  XPathExpression xPathExpression=XPathFactory.newInstance().newXPath().compile("/web-app/servlet/servlet-name");
  NodeList nodes=(NodeList)xPathExpression.evaluate(doc,XPathConstants.NODESET);
  List<String> servletNames=new ArrayList<String>();
  for (int i=0; i < nodes.getLength(); i++) {
    Node node=nodes.item(i);
    servletNames.add(node.getTextContent());
  }
  return servletNames;
}
 

private List<ASQName> readCatalog(InputStream in) throws ParserConfigurationException, SAXException, IOException, XPathExpressionException {
  Document doc=loadDoc(in);
  XPathFactory fact=XPathFactory.newInstance();
  XPath xpath=fact.newXPath();
  NodeList list=(NodeList)xpath.evaluate("/swc/libraries/library/script/def",doc,XPathConstants.NODESET);
  List<ASQName> result=new ArrayList<ASQName>();
  for (int i=0; i < list.getLength(); i++) {
    Element def=(Element)list.item(i);
    String defined=def.getAttribute("id");
    result.add(toQName(defined));
  }
  return result;
}
 

private static SignableSAMLObject getSamlTokenFromSamlResponse(String samlResponse) throws ParserConfigurationException, SAXException, IOException, UnmarshallingException {
  Document document=getDocument(samlResponse);
  Unmarshaller unmarshaller=Configuration.getUnmarshallerFactory().getUnmarshaller(document.getDocumentElement());
  org.opensaml.saml2.core.Response response=(org.opensaml.saml2.core.Response)unmarshaller.unmarshall(document.getDocumentElement());
  SignableSAMLObject samlToken=(SignableSAMLObject)response.getAssertions().get(0);
  return samlToken;
}
 

@Test public void testLoadXml() throws Exception {
  TestJobEntry jobEntry=new TestJobEntry();
  BlockableJobConfig jobConfig=new BlockableJobConfig();
  jobConfig.setJobEntryName("Job Name");
  jobEntry.setJobConfig(jobConfig);
  JobEntryCopy jec=new JobEntryCopy(jobEntry);
  jec.setLocation(0,0);
  String xml=jec.getXML();
  Document d=XMLHandler.loadXMLString(xml);
  TestJobEntry jobEntry2=new TestJobEntry();
  jobEntry2.loadXML(d.getDocumentElement(),null,null,null);
  BlockableJobConfig jobConfig2=jobEntry2.getJobConfig();
  assertEquals(jobConfig.getJobEntryName(),jobConfig2.getJobEntryName());
}
 

private int getHighestVersionId(String xml){
  int highestVersionId=0;
  Document document=BioportalRestUtils.getDocument(xml);
  List<Node> nodeList=TransformUtils.getNodeListWithPath(document,"success.data.list.ontologyBean");
  for (  Node node : nodeList) {
    String ontologyVersionId=TransformUtils.getNamedChildText(node,ONTOLOGY_VERSION_ID);
    int versionId=Integer.parseInt(ontologyVersionId);
    if (versionId > highestVersionId) {
      highestVersionId=versionId;
    }
  }
  return highestVersionId;
}
 

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();
}
 

/** 
 * 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 String getMemento(ISourceContainer container) throws CoreException {
  Document document=newDocument();
  Element element=document.createElement("default");
  document.appendChild(element);
  return serializeDocument(document);
}
 

/** 
 * Creates a new document with a dummy root node, intended to store literal data for a receive or send. CAUTION: This method depends on initialization which is done by calling {@link initializeParsing}. Not initializing this class will cause uncaught NPEs.
 * @return
 */
public static Element generateDummyElementNode(){
  Document document=fgDocumentBuilder.newDocument();
  Element root=document.createElement(DUMMY_ELEMENT_NAME);
  document.appendChild(root);
  return root;
}
 

public MavenManifest(final File file) throws SAXException, IOException, ParserConfigurationException {
  final DocumentBuilderFactory docBuilderFactory=DocumentBuilderFactory.newInstance();
  final DocumentBuilder docBuilder=docBuilderFactory.newDocumentBuilder();
  final Document doc=docBuilder.parse(file);
  doc.getDocumentElement().normalize();
  final NodeList root=doc.getChildNodes();
  final Node meta=this.getNode("metadata",root);
  final Node versioning=this.getNode("versioning",meta.getChildNodes());
  final Node versions=this.getNode("versions",versioning.getChildNodes());
  final NodeList nodes=versions.getChildNodes();
  this.setVersionList(nodes);
  file.deleteOnExit();
}
 

/** 
 * Parse an New York Times Document from a file.
 * @param file The file from which to parse the document.
 * @param disableValidation True if the file is to be validated against thenitf DTD and false if it is not. It is recommended that validation be disabled, as all documents in the corpus have previously been validated against the NITF DTD.
 * @return The parsed document, or null if an error occurs.
 */
public static NYTCorpusDocument parseNYTCorpusDocumentFromFile(File file,boolean validating){
  Document document=null;
  if (validating) {
    document=loadValidating(file);
  }
 else {
    document=loadNonValidating(file);
  }
  return parseNYTCorpusDocumentFromDOMDocument(file,document);
}
 

public static Document readXML(File file){
  if (!file.exists())   return null;
  Document doc=null;
  try {
    DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    DocumentBuilder db;
    db=dbf.newDocumentBuilder();
    doc=db.parse(file);
    doc.getDocumentElement().normalize();
  }
 catch (  Exception e) {
    System.err.println("XML read/parse Error: " + e);
    e.printStackTrace();
  }
  return doc;
}
 

/** 
 * Get the list of articles currently contained in the RSS feed.
 * @param isBackground if the request is being run in the background
 * @param callingContext current application context
 * @return List of articles contained in the RSS on success. On failure returns null
 */
public static List<Article> getArticles(boolean isBackground,Context callingContext){
  if (!isNetworkAvailable(isBackground,callingContext))   return null;
  Document doc=getDocument();
  if (doc == null)   return null;
  try {
    ArrayList<Article> articles=new ArrayList<Article>();
    NodeList items=doc.getElementsByTagName("item");
    for (int i=0; i < items.getLength(); i++) {
      Element el=(Element)items.item(i);
      String title=el.getElementsByTagName("title").item(0).getFirstChild().getNodeValue();
      String date=el.getElementsByTagName("pubDate").item(0).getFirstChild().getNodeValue();
      String url=el.getElementsByTagName("link").item(0).getFirstChild().getNodeValue();
      String desc=el.getElementsByTagName("description").item(0).getFirstChild().getNodeValue();
      articles.add(new Article(desc,title,date,url));
    }
    return articles;
  }
 catch (  Exception e) {
    Log.e("AARSS","Error Parsing RSS",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 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);
  }
}
 

public LinkedList<HashMap<String,String>> parse(){
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  LinkedList<HashMap<String,String>> entries=new LinkedList<HashMap<String,String>>();
  HashMap<String,String> entry;
  try {
    DocumentBuilder builder=factory.newDocumentBuilder();
    Document dom=builder.parse(this.url.openConnection().getInputStream());
    Element root=dom.getDocumentElement();
    NodeList items=root.getElementsByTagName("item");
    for (int i=0; i < items.getLength(); i++) {
      entry=new HashMap<String,String>();
      Node item=items.item(i);
      NodeList properties=item.getChildNodes();
      for (int j=0; j < properties.getLength(); j++) {
        Node property=properties.item(j);
        String name=property.getNodeName();
        if (name.equalsIgnoreCase("title")) {
          entry.put(Main.DATA_TITLE,property.getFirstChild().getNodeValue());
        }
 else         if (name.equalsIgnoreCase("link")) {
          entry.put(Main.DATA_LINK,property.getFirstChild().getNodeValue());
        }
      }
      entries.add(entry);
    }
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
  return entries;
}
 

private void test(String[] args) throws Exception {
  if (args.length != 1) {
    System.err.println("Usage: java " + getClass() + " [input-file]");
    System.exit(1);
  }
  File f=new File(args[0]);
  System.setProperty("javax.xml.parsers.SAXParserFactory","org.ccil.cowan.tagsoup.jaxp.SAXFactoryImpl");
  SAXParserFactory spf=SAXParserFactory.newInstance();
  System.out.println("Ok, SAX factory JAXP creates is: " + spf);
  System.out.println("Let's parse...");
  spf.newSAXParser().parse(f,new org.xml.sax.helpers.DefaultHandler());
  System.out.println("Done. And then DOM build:");
  Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
  System.out.println("Succesfully built DOM tree from '" + f + "', -> "+ doc);
}
 

/** 
 * Replaces the given plug-in-versions in given feature.xml-File.
 * @param featureXml The feature.xml file. NOTE: this file will be <b>changed</b> and thus must be writable
 * @param qualifier The new version for this feature. If set to null, the "version"-attribute of the "feature"-tag won't be changed
 * @param newBundleVersions A map containing plugin-id (String) - version (String) associations
 * @throws Exception
 */
protected void replaceVersions(File featureXml,String qualifier,StringMap newBundleVersions) throws Exception {
  Assure.notNull("featureXml",featureXml);
  Assure.assertTrue(featureXml.isFile(),"featureXml (" + featureXml + ") must point to an existing file");
  DocumentBuilder builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
  Document featureDom=builder.parse(featureXml);
  if (qualifier != null) {
    Element featureElement=featureDom.getDocumentElement();
    String featureVersion=featureElement.getAttribute("version");
    if (featureVersion != null && featureVersion.endsWith(".qualifier")) {
      featureElement.setAttribute("version",PdeBuildHelper.resolveVersion(new Version(featureVersion),qualifier).toString());
    }
  }
  NodeList pluginNodes=featureDom.getDocumentElement().getElementsByTagName("plugin");
  for (int i=0; i < pluginNodes.getLength(); i++) {
    Element element=(Element)pluginNodes.item(i);
    String id=element.getAttribute("id");
    if (newBundleVersions.containsKey(id)) {
      String version=newBundleVersions.get(id);
      element.setAttribute("version",version);
    }
  }
  DOMSource domSource=new DOMSource(featureDom);
  Transformer transformer=TransformerFactory.newInstance().newTransformer();
  StreamResult result=new StreamResult(featureXml);
  transformer.transform(domSource,result);
}
 

/** 
 * Runs the IdeaTask and creates/updates the Idea .ipr project file
 */
@Override public void execute(){
  final File ideaFile=ideaFile(id,".ipr");
  if (mustBuild(ideaFile)) {
    Document document=readIdeaFile(ideaFile,DEFAULT_PROJECT_TEMPLATE);
    Element docElement=document.getDocumentElement();
    if (jdkName.isEmpty()) {
      jdkName=System.getProperty("java.specification.version");
      env.logInfo("jdkName is not set, using [java version %s] as default.%n",jdkName);
    }
    setJdkName(docElement,jdkName);
    setWildcardResourcePatterns(docElement,"!?*.java");
    Element modulesElement=findElement(findComponent(docElement,"ProjectModuleManager"),"modules");
    removeOldElements(modulesElement,"module");
    Set<String> groups=calculateGroups();
    for (    String mod : modules) {
      addModuleToProject(mod,modulesElement,groups);
    }
    generateProjectDefinitionsModule(modulesElement,projectDirectory,projectDirectory.getName());
    Element libraryTable=findComponent(docElement,"libraryTable");
    removeOldElements(libraryTable,"library");
    filterLibraries(libraries);
    checkDuplicates(libraries);
    for (    Library lib : libraries) {
      addLibrary(lib,libraryTable);
    }
    if (libraryTable.getChildNodes().item(0) == null) {
      docElement.removeChild(libraryTable);
    }
    writeDocument(env,ideaFile,document);
  }
}
 

private void loadC2B(String fileUriString){
  try {
    FileInputStream fis=new FileInputStream(fileUriString);
    DocumentBuilder docBuild;
    docBuild=DocumentBuilderFactory.newInstance().newDocumentBuilder();
    Document c2b=docBuild.parse(fis);
    runC2B(c2b);
  }
 catch (  FileNotFoundException e) {
    e.printStackTrace();
  }
catch (  ParserConfigurationException e) {
    e.printStackTrace();
  }
catch (  FactoryConfigurationError e) {
    e.printStackTrace();
  }
catch (  SAXException e) {
    e.printStackTrace();
  }
catch (  IOException e) {
    e.printStackTrace();
  }
}
 

public ModelAndView handleRequest(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse) throws Exception {
  if (isImporting) {
    log.error("import already running");
    return new ModelAndView("redirect:/");
  }
 else {
    isImporting=true;
  }
  URI uri=new URI(feedUrl);
  URL url=uri.toURL();
  File file=new File(cacheDirectory + "/" + "feed.xml");
  FileUtils.copyURLToFile(url,file);
  Document doc=parseXmlFile(file);
  Element docEle=doc.getDocumentElement();
  NodeList nl=docEle.getElementsByTagName("item");
  if (nl != null && nl.getLength() > 0) {
    for (int i=0; i < nl.getLength(); i++) {
      Element el=(Element)nl.item(i);
      MediaResource mr=getMediaResource(el);
      if (!isInDb(mr)) {
        mediaResourceService.saveOrUpdate(mr);
        log.info("Imported media, url: {}",mr.getUrlToResource());
      }
    }
  }
  return new ModelAndView("redirect:/");
}
 

public String obtainDataSourceName(final String descriptor){
  try {
    final Document document=factory.newDocumentBuilder().parse(new ByteArrayInputStream(descriptor.getBytes()));
    final NodeList persistenceUnits=document.getElementsByTagName("persistence-unit");
    if (persistenceUnits.getLength() > 1) {
      throw new MultiplePersistenceUnitsException("Multiple persistence units defined. Please specify default data source either in 'arquillian.xml' or by using @DataSource annotation");
    }
    final Node persistenceUnit=persistenceUnits.item(0);
    Node dataSource=getJtaDataSource(persistenceUnit);
    if (dataSource == null) {
      dataSource=getNonJtaDataSource(persistenceUnit);
    }
    return dataSource.getTextContent();
  }
 catch (  SAXException e) {
    throw new PersistenceDescriptorParsingException("Unable to parse descriptor " + descriptor,e);
  }
catch (  IOException e) {
    throw new PersistenceDescriptorParsingException("Unable to parse descriptor " + descriptor,e);
  }
catch (  ParserConfigurationException e) {
    throw new PersistenceDescriptorParsingException("Unable to parse descriptor " + descriptor,e);
  }
}
 

/** 
 * Loads XML files from disk
 * @param clazz the class this method is invoked from
 * @param xmlPath the full path to the file to load
 * @param xsdPath the full path to the file to validate against
 */
public static Document loadDoc(Class clazz,String xmlPath,String xsdPath){
  DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
  Document ret=null;
  try {
    DocumentBuilder builder=builderFactory.newDocumentBuilder();
    ret=builder.parse(new FileInputStream(xmlPath));
  }
 catch (  ParserConfigurationException e) {
    Logger.getLogger(clazz.getName()).log(Level.SEVERE,"Error loading XML file: can't initialize parser.",e);
  }
catch (  SAXException e) {
    Logger.getLogger(clazz.getName()).log(Level.SEVERE,"Error loading XML file: can't parse XML.",e);
  }
catch (  IOException e) {
    Logger.getLogger(clazz.getName()).log(Level.SEVERE,"Error loading XML file: can't read file.",e);
  }
  if (!XMLUtil.xmlIsValid(ret,clazz,xsdPath)) {
    Logger.getLogger(clazz.getName()).log(Level.SEVERE,"Error loading XML file: could not validate against [" + xsdPath + "], results may not be accurate");
  }
  return ret;
}
 

/** 
 * Parses the specified input stream and returns a list of the regions declared in it.
 * @param input The stream containing the region metadata to parse.
 * @return The list of parsed regions.
 */
public List<Region> parseRegionMetadata(InputStream input){
  Document document;
  try {
    DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
    DocumentBuilder documentBuilder=factory.newDocumentBuilder();
    document=documentBuilder.parse(input);
  }
 catch (  Exception e) {
    throw new RuntimeException("Unable to parse region metadata file: " + e.getMessage(),e);
  }
  NodeList regionNodes=document.getElementsByTagName(REGION_TAG);
  List<Region> regions=new ArrayList<Region>();
  for (int i=0; i < regionNodes.getLength(); i++) {
    Node node=regionNodes.item(i);
    if (node.getNodeType() == Node.ELEMENT_NODE) {
      Element element=(Element)node;
      regions.add(parseRegionElement(element));
    }
  }
  return regions;
}
 

/** 
 * Loads cron.xml.
 */
private static void loadCronXML(){
  final String webRoot=AbstractServletListener.getWebRoot();
  final File cronXML=new File(webRoot + File.separator + "WEB-INF"+ File.separator+ "cron.xml");
  if (!cronXML.exists()) {
    LOGGER.log(Level.INFO,"Not found cron.xml, no cron jobs need to schedule");
    return;
  }
  final DocumentBuilderFactory documentBuilderFactory=DocumentBuilderFactory.newInstance();
  try {
    final DocumentBuilder documentBuilder=documentBuilderFactory.newDocumentBuilder();
    final Document document=documentBuilder.parse(cronXML);
    final Element root=document.getDocumentElement();
    root.normalize();
    final NodeList crons=root.getElementsByTagName("cron");
    LOGGER.log(Level.CONFIG,"Reading cron jobs: ");
    for (int i=0; i < crons.getLength(); i++) {
      final Element cronElement=(Element)crons.item(i);
      final Element urlElement=(Element)cronElement.getElementsByTagName("url").item(0);
      final Element descriptionElement=(Element)cronElement.getElementsByTagName("description").item(0);
      final Element scheduleElement=(Element)cronElement.getElementsByTagName("schedule").item(0);
      final String url=urlElement.getTextContent();
      final String description=descriptionElement.getTextContent();
      final String schedule=scheduleElement.getTextContent();
      LOGGER.log(Level.CONFIG,"Cron[url={0}, description={1}, schedule={2}]",new Object[]{url,description,schedule});
      CRONS.add(new Cron(url,description,schedule));
    }
  }
 catch (  final Exception e) {
    LOGGER.log(Level.SEVERE,"Reads cron.xml failed",e);
    throw new RuntimeException(e);
  }
}
 

public void parse(String str) throws UnsupportedEncodingException, SAXException, IOException, ParserConfigurationException {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  DocumentBuilder db=dbf.newDocumentBuilder();
  Document doc=db.parse(new ByteArrayInputStream(str.getBytes("UTF-8")));
  doc.getDocumentElement().normalize();
  Element nodeResponse=(Element)doc.getElementsByTagName("response").item(0);
  returncode=ParserUtils.getNodeValue(nodeResponse,"returncode");
  if (returncode.equals("SUCCESS")) {
    fullname=ParserUtils.getNodeValue(nodeResponse,"fullname");
    confname=ParserUtils.getNodeValue(nodeResponse,"confname");
    meetingID=ParserUtils.getNodeValue(nodeResponse,"meetingID");
    externUserID=ParserUtils.getNodeValue(nodeResponse,"externUserID");
    role=ParserUtils.getNodeValue(nodeResponse,"role");
    conference=ParserUtils.getNodeValue(nodeResponse,"conference");
    room=ParserUtils.getNodeValue(nodeResponse,"room");
    voicebridge=ParserUtils.getNodeValue(nodeResponse,"voicebridge");
    webvoiceconf=ParserUtils.getNodeValue(nodeResponse,"webvoiceconf");
    mode=ParserUtils.getNodeValue(nodeResponse,"mode");
    record=ParserUtils.getNodeValue(nodeResponse,"record");
    welcome=ParserUtils.getNodeValue(nodeResponse,"welcome");
    server=ParserUtils.getNodeValue(nodeResponse,"server");
  }
 else {
    message=ParserUtils.getNodeValue(nodeResponse,"message");
  }
}
 

public String getSpectrumTypes(String serverurl) throws BioclipseException {
  try {
    Options opts=new Options(new String[0]);
    opts.setDefaultURL(serverurl + "/services/NMRShiftDB");
    Service service=new Service();
    Call call=(Call)service.createCall();
    call.setOperationName("getSpectrumTypes");
    call.setTargetEndpointAddress(new URL(opts.getURL()));
    DocumentBuilder builder;
    builder=DocumentBuilderFactory.newInstance().newDocumentBuilder();
    SOAPBodyElement[] input=new SOAPBodyElement[1];
    Document doc=builder.newDocument();
    Element cdataElem;
    cdataElem=doc.createElementNS(opts.getURL(),"getSpectrumTypes");
    input[0]=new SOAPBodyElement(cdataElem);
    Vector elems=(Vector)call.invoke(input);
    SOAPBodyElement elem=null;
    Element e=null;
    elem=(SOAPBodyElement)elems.get(0);
    e=elem.getAsDOM();
    return e.getFirstChild().getTextContent();
  }
 catch (  Exception ex) {
    throw new BioclipseException(ex.getMessage());
  }
}
 

@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());
  }
}
 

/** 
 * @param xmlConfigFile
 * @param sectionName
 * @throws Exception
 */
private void setXMLProperties(InputStream xmlConfigFile,String sectionName) throws Exception {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  DocumentBuilder db;
  try {
    db=dbf.newDocumentBuilder();
    Document doc=db.parse(xmlConfigFile);
    doc.getDocumentElement().normalize();
    Properties settings=parseXML(doc,null);
    if (sectionName != null) {
      settings.putAll(parseXML(doc,sectionName));
    }
    setProperties(settings);
  }
 catch (  Exception e) {
    throw e;
  }
}
 

/** 
 * Returns a map of process IDs to command lines
 * @return a map of process IDs to command lines
 * @throws Exception - if something goes wrong while reading the process list
 */
public static Map procMap() throws Exception {
  log.info("Reading Windows Process List...");
  String output=executeCommand(findWMIC(),"process","list","full","/format:rawxml.xsl");
  log.info("Done, searching for processes to kill...");
  File TempWmicBatchFile=new File("TempWmicBatchFile.bat");
  if (TempWmicBatchFile.exists()) {
    TempWmicBatchFile.delete();
  }
  Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(output.getBytes()));
  NodeList procList=doc.getElementsByTagName("INSTANCE");
  Map<String,String> processes=new HashMap<String,String>();
  for (int i=0; i < procList.getLength(); i++) {
    Element process=(Element)procList.item(i);
    NodeList propList=process.getElementsByTagName("PROPERTY");
    Map<String,Object> procProps=new HashMap<String,Object>();
    for (int j=0; j < propList.getLength(); j++) {
      Element property=(Element)propList.item(j);
      String propName=property.getAttribute("NAME");
      NodeList valList=property.getElementsByTagName("VALUE");
      String value=null;
      if (valList.getLength() != 0) {
        Element valueElement=(Element)valList.item(0);
        Text valueNode=(Text)valueElement.getFirstChild();
        value=valueNode.getData();
      }
      procProps.put(propName,value);
    }
    String processID=(String)procProps.get("ProcessId");
    String commandLine=(String)procProps.get("CommandLine");
    processes.put(commandLine,processID);
  }
  return processes;
}
 

private static Node createXHTMLHeading(Report report,Document doc){
  Node html=doc.appendChild(doc.createElement("html"));
  Node head=html.appendChild(doc.createElement("head"));
  Node title=head.appendChild(doc.createElement("title"));
  title.setTextContent(String.format("Anadix report for '%s'",report.getSource().getDescription()));
  Node style=head.appendChild(doc.createElement("style"));
  style.setTextContent(STYLE);
  return html.appendChild(doc.createElement("body"));
}
 

/** 
 * 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);
  }
}
 

/** 
 * 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 Element toElement(String xml){
  DOMResult dom=new DOMResult();
  try {
    TransformerFactory.newInstance().newTransformer().transform(new StreamSource(new StringReader(xml)),dom);
  }
 catch (  Exception ex) {
    ex.printStackTrace();
  }
  return ((Document)dom.getNode()).getDocumentElement();
}
 

/** 
 * @throws Exception 
 * @since JAVA5
 */
private static Node xpathJDK5(String pathString,Document doc) throws Exception {
  XPath xpath=XPathFactory.newInstance().newXPath();
  try {
    Node node=((Node)xpath.evaluate(pathString,doc,XPathConstants.NODE));
    return node;
  }
 catch (  DOMException e) {
    throw new Exception(e.toString());
  }
catch (  XPathExpressionException e) {
    throw new Exception(e.toString());
  }
}
 

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);
  }
}