public WikipediaConfig() throws XPathExpressionException {
   contentPath = xpath.compile(ConfigDefaults.XPATH_CONTENT);
   descriptionPath = xpath.compile(ConfigDefaults.XPATH_DESCRIPTION);
   redirectPath = xpath.compile(ConfigDefaults.XPATH_REDIRECT_URL);
   referencesPath = xpath.compile(ConfigDefaults.XPATH_REFERENCES);
   referenceUrlPath = xpath.compile(ConfigDefaults.XPATH_REFERENCE_URL);
 }
Example #2
0
    @Override
    public void run() {
      final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      final XPath xPath = XPathFactory.newInstance().newXPath();
      final String expression = "//" + TAG_TRACK_POINT;
      final String speedExpression = "//" + TAG_SPEED;

      NodeList nodeList = null;
      NodeList speedList = null;
      try {
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(traceFile);
        nodeList = (NodeList) xPath.compile(expression).evaluate(document, XPathConstants.NODESET);
        speedList =
            (NodeList) xPath.compile(speedExpression).evaluate(document, XPathConstants.NODESET);
      } catch (ParserConfigurationException e) {
        e.printStackTrace();
      } catch (SAXException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      } catch (XPathExpressionException e) {
        e.printStackTrace();
      }

      parse(nodeList, speedList);
    }
  public List<String> getOriginCatalogs() {

    XPathFactory xpathFactory = XPathFactory.newInstance();
    XPath xpath = xpathFactory.newXPath();

    List<String> catalogs = new ArrayList<String>();
    try {
      XPathExpression expr = xpath.compile("//Resolver");

      NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
      for (int i = 0; i < nodes.getLength(); i++) {
        XPathExpression hasAliasExp = xpath.compile("./alias");
        NodeList aliases = (NodeList) hasAliasExp.evaluate(nodes.item(i), XPathConstants.NODESET);
        if (aliases.getLength() > 0) {
          XPathExpression nameAttribute = xpath.compile("@name");
          String name = (String) nameAttribute.evaluate(nodes.item(i), XPathConstants.STRING);
          catalogs.add(name);
        }
      }

    } catch (XPathExpressionException e) {
      e.printStackTrace();
    }

    return catalogs;
  }
  public Location getLocationData() {
    Location location = new Location();
    try {

      LocationDoc = builder.parse(new FileInputStream("location.xml"));
      String ExtendedNameExpression = "/GeocodeResponse/result/formatted_address/text()";
      String LatitudeExpression = "/GeocodeResponse/result/geometry/location/lat/text()";
      String LongitudeExpression = "/GeocodeResponse/result/geometry/location/lng/text()";
      String ShortNameExpression = "/GeocodeResponse/result/address_component/short_name/text()";

      XPath xPath = XPathFactory.newInstance().newXPath();
      // read a string value
      location.setExtendedName(xPath.compile(ExtendedNameExpression).evaluate(LocationDoc));

      location.setLatitude(
          Float.parseFloat(xPath.compile(LatitudeExpression).evaluate(LocationDoc)));

      location.setLongitude(
          Float.parseFloat(xPath.compile(LongitudeExpression).evaluate(LocationDoc)));

      location.setName(xPath.compile(ShortNameExpression).evaluate(LocationDoc));

      // read an xml node using xpath

    } catch (Exception ex) {
      Logger.getLogger(DataFiller.class.getName()).log(Level.SEVERE, null, ex);
    }
    System.out.println(location);
    return location;
  }
 {
   try {
     appletClassXPression = xPath.compile("/applet-app/applet/applet-class/text()"); // NOI18N
     appletAIDXPression = xPath.compile("/applet-app/applet/applet-AID/text()"); // NOI18N
   } catch (XPathExpressionException e) {
     Exceptions.printStackTrace(e);
   }
 }
 {
   try {
     linksXPath = xpath.compile("//a/@href");
     scriptXPath = xpath.compile("//head/script/@src");
     imgsXPath = xpath.compile("//img/@src");
   } catch (XPathExpressionException e) {
     // will only occur if a bug prevents class from loading
     // should never occur if class passes ANY unit test
     throw new AssertionError("Shouldn't get here", e);
   }
 }
 public LFParseEnricher() {
   XPathFactory factory = XPathFactory.newInstance();
   xpath = factory.newXPath();
   try {
     theoryXPath = xpath.compile("//theory");
     viewXPath = xpath.compile("//view");
     viewXPath = xpath.compile("//include");
   } catch (XPathExpressionException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
 private void reportAndVerify(String conceptName, int assertedEdges) throws Exception {
   Document doc = scanAndWriteReport(conceptName, TestClass.class);
   XPathFactory xPathfactory = XPathFactory.newInstance();
   XPath xpath = xPathfactory.newXPath();
   XPathExpression classExpression =
       xpath.compile("/graphml/graph/node[contains(@labels,':Class')]/data[@key='fqn']");
   String fqn = classExpression.evaluate(doc);
   assertThat(fqn, equalTo(TestClass.class.getName()));
   XPathExpression declaresExpression = xpath.compile("//edge");
   NodeList edges = (NodeList) declaresExpression.evaluate(doc, XPathConstants.NODESET);
   assertThat(edges.getLength(), equalTo(assertedEdges));
 }
Example #9
0
 static {
   XPathFactory xPathFactory = XPathFactory.newInstance();
   XPath xpath = xPathFactory.newXPath();
   try {
     tokenIdExpression = xpath.compile("/access/token/@id");
     publicUrlExpression =
         xpath.compile(
             "/access/serviceCatalog/service[@type='object-store']/endpoint/@publicURL");
   } catch (XPathExpressionException e) {
     // Do nothing
   }
 }
 // CreateShortcut, LoadResource, InitDiagramFileAction
 public void testPredefinedActions() throws Exception {
   DiaGenSource s1 = createLibraryGen(false);
   final GenEditorGenerator editorGen = s1.getGenDiagram().getEditorGen();
   GenContextMenu menu = GMFGenFactory.eINSTANCE.createGenContextMenu();
   menu.getContext().add(s1.getGenDiagram());
   final CreateShortcutAction createShortcutAction =
       GMFGenFactory.eINSTANCE.createCreateShortcutAction();
   final LoadResourceAction loadResourceAction =
       GMFGenFactory.eINSTANCE.createLoadResourceAction();
   menu.getItems().add(createShortcutAction);
   menu.getItems().add(loadResourceAction);
   editorGen.getContextMenus().clear(); // make sure there's no other (default) menus
   editorGen.getContextMenus().add(menu);
   editorGen.getDiagram().getContainsShortcutsTo().add("ecore");
   assertTrue("sanity", editorGen.getDiagram().generateCreateShortcutAction());
   //
   generateAndCompile(s1);
   //
   IProject generatedProject =
       ResourcesPlugin.getWorkspace().getRoot().getProject(editorGen.getPlugin().getID());
   IFile generatedManifest = generatedProject.getFile("plugin.xml");
   assertTrue(generatedManifest.exists());
   DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   Document parsedManifest = db.parse(new InputSource(generatedManifest.getContents()));
   XPath xf = XPathFactory.newInstance().newXPath();
   XPathExpression xe =
       xf.compile("/plugin/extension[@point = 'org.eclipse.ui.menus']/menuContribution/command");
   NodeList result = (NodeList) xe.evaluate(parsedManifest, XPathConstants.NODESET);
   assertEquals(2, result.getLength());
   xe = xf.compile("/plugin/extension[@point = 'org.eclipse.ui.commands']/command");
   result = (NodeList) xe.evaluate(parsedManifest, XPathConstants.NODESET);
   assertTrue(result.getLength() > 2);
   HashSet<String> allCommands = new HashSet<String>();
   for (int i = result.getLength() - 1; i >= 0; i--) {
     allCommands.add(result.item(i).getAttributes().getNamedItem("defaultHandler").getNodeValue());
   }
   assertTrue(allCommands.contains(createShortcutAction.getQualifiedClassName()));
   assertTrue(allCommands.contains(loadResourceAction.getQualifiedClassName()));
   IFile file1 =
       generatedProject.getFile(
           "/src/" + createShortcutAction.getQualifiedClassName().replace('.', '/') + ".java");
   IFile file2 =
       generatedProject.getFile(
           "/src/" + loadResourceAction.getQualifiedClassName().replace('.', '/') + ".java");
   assertTrue(file1.exists());
   assertTrue(file2.exists());
   //
   //		DiaGenSource s2 = createLibraryGen(true);
   //		fail("TODO");
 }
  /**
   * Returns a list of ref nodes from the ref-list of the DOM.
   *
   * @param doc DOM representation of the XML
   * @return NodeList of ref elements
   * @throws XPathExpressionException
   */
  private NodeList getReferenceNodes(Document doc) throws XPathExpressionException {
    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();
    XPathExpression expr = xpath.compile("//back/ref-list[title='References']/ref");
    Object result = expr.evaluate(doc, XPathConstants.NODESET);

    NodeList refList = (NodeList) result;

    if (refList.getLength() == 0) {
      expr = xpath.compile("//back/ref-list/ref");
      result = expr.evaluate(doc, XPathConstants.NODESET);
      refList = (NodeList) result;
    }
    return refList;
  }
  private String handleResponse(HttpResponse httpResponse) throws IOException {
    final int ok = 200;
    if (httpResponse.getStatusLine().getStatusCode() == ok) {
      String reply = IOUtils.toString(httpResponse.getEntity().getContent());

      if (reply == null) {
        LOGGER.error("Http request failed. Service did not respond.");
        return "-";
      }

      try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(new ByteArrayInputStream(reply.getBytes()));
        XPathFactory xPathfactory = XPathFactory.newInstance();
        XPath xpath = xPathfactory.newXPath();

        XPathExpression expr = xpath.compile("/calendarItems/status/text()");

        String status = expr.evaluate(doc);

        if ("PROCESSED".equals(status)) {
          String res = xpath.compile("/calendarItems/total/text()").evaluate(doc);
          return res;
        } else {
          return ""; // The user does not have any notes calendar and should receive nothing.
        }

      } catch (RuntimeException ex) {
        LOGGER.warn(ex.getMessage());
      } catch (ParserConfigurationException e) {
        LOGGER.warn(e.getMessage());
      } catch (SAXException e) {
        LOGGER.warn(e.getMessage());
      } catch (XPathExpressionException e) {
        LOGGER.warn(e.getMessage());
      }

      return "-";
    } else {
      LOGGER.error(
          "Http request failed. Response code="
              + httpResponse.getStatusLine().getStatusCode()
              + ". "
              + httpResponse.getStatusLine().getReasonPhrase());
      return "-";
    }
  }
Example #13
0
  private Integer fromCitation(Document doc, XPath xpath) {
    try {
      XPathExpression expr = xpath.compile("//p");
      NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);

      for (int i = 0; i < nodes.getLength(); i++) {
        Node node = nodes.item(i);
        Node classNode = node.getAttributes().getNamedItem("class");
        if (classNode == null) continue;
        String pClass = classNode.getTextContent();
        if (pClass.equalsIgnoreCase("case_cite")) {
          String citationString = node.getTextContent();
          Matcher citationYearMatcher = citationYearPattern.matcher(citationString);
          boolean foundDate = citationYearMatcher.matches();
          if (foundDate) {
            String yearString = citationYearMatcher.group(1).toString();
            return Integer.parseInt(yearString);
          }
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }
  /**
   * Takes an XML file containing parameterised queries + parameter queries and substitutes
   * parameters for values, then saves the resulting queries
   *
   * @param queryFileName the XML query file
   * @param queryMixFile
   * @param ignoreFile
   */
  public void generateQueries(String queryFileName, String queryMixFile, String ignoreFile) {
    File queryFile = new File(queryFileName);
    try {

      DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
      Document doc = docBuilder.parse(queryFile);

      XPath xpath = XPathFactory.newInstance().newXPath();
      XPathExpression expr = xpath.compile("/queries/query");
      Object result = expr.evaluate(doc, XPathConstants.NODESET);
      NodeList nodes = (NodeList) result;

      // for each query, generate a map of parameter names and values
      //            then replace the parameters in the final query with the respective (randomly
      // selected) values
      for (int i = 0; i < nodes.getLength(); i++) {
        queryCount = i + 1;
        String completeQuery = generateCompleteQuery(nodes.item(i), doc);
        saveCompleteQuery(completeQuery);
      }
      saveHelperFiles(queryMixFile, ignoreFile);

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Example #15
0
  /**
   * Get container window
   *
   * <p>
   *
   * @return String
   */
  private String getWindowName(String sWidgetID) {

    String sWindowName = null;
    // get widget ID
    XPath xpath = XPathFactory.newInstance().newXPath();
    XPathExpression expr;
    Object result;
    NodeList nodes;
    try {
      String xpathExpression =
          "/GUIStructure/GUI[Container//Property[Name=\""
              + GUITARConstants.ID_TAG_NAME
              + "\" and Value=\""
              + sWidgetID
              + "\"]]/Window/Attributes/Property[Name=\""
              + GUITARConstants.TITLE_TAG_NAME
              + "\"]/Value/text()";
      expr = xpath.compile(xpathExpression);
      result = expr.evaluate(docGUI, XPathConstants.NODESET);
      nodes = (NodeList) result;
      if (nodes.getLength() > 0) sWindowName = nodes.item(0).getNodeValue();
    } catch (XPathExpressionException e) {
      GUITARLog.log.error(e);
    }
    return sWindowName;
  }
  @Override
  public void addAssociation(
      String associationName, String workflowId, String eventId, String condition)
      throws WorkflowException {

    if (StringUtils.isBlank(workflowId)) {
      log.error("Null or empty string given as workflow id to be associated to event.");
      throw new InternalWorkflowException("Service alias cannot be null");
    }
    if (StringUtils.isBlank(eventId)) {
      log.error("Null or empty string given as 'event' to be associated with the service.");
      throw new InternalWorkflowException("Event type cannot be null");
    }

    if (StringUtils.isBlank(condition)) {
      log.error(
          "Null or empty string given as condition expression when associating "
              + workflowId
              + " to event "
              + eventId);
      throw new InternalWorkflowException("Condition cannot be null");
    }

    // check for xpath syntax errors
    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();
    try {
      xpath.compile(condition);
      workflowDAO.addAssociation(associationName, workflowId, eventId, condition);
    } catch (XPathExpressionException e) {
      log.error("The condition:" + condition + " is not an valid xpath expression.", e);
      throw new WorkflowRuntimeException("The condition is not a valid xpath expression.");
    }
  }
  public static void main(String[] args) {

    CodeExtractor myCode = new CodeExtractor(4);
    // myCode.parseFile("http://java.sun.com/docs/books/tutorial/java/nutsandbolts/for.html");
    myCode.parseFile("http://www.javadeveloper.co.in/java-example/java-hashmap-example.html");

    String docString = myCode.getDoc();
    try {
      XPath xPath = XPathFactory.newInstance().newXPath();
      XPathExpression nodeXPathExpr =
          xPath.compile("/codesnippets/text | /codesnippets/sourcecode");
      InputSource inputSource = new InputSource(new ByteArrayInputStream(docString.getBytes()));

      NodeList allNodes = (NodeList) nodeXPathExpr.evaluate(inputSource, XPathConstants.NODESET);

      int nodeNumber = allNodes.getLength();
      System.out.println("Text Found:: " + nodeNumber + " nodes.");
      System.out.println("========================================");

      for (int i = 0; i < nodeNumber; i++) {
        Node node = allNodes.item(i);

        String content = node.getTextContent();
        // content = StringEscapeUtils.unescapeHtml(content).trim();
        System.out.println(node + ":--->:" + node.getNodeName());
        if (node.getTextContent() != null) System.out.println("--->" + content);
        System.out.println("========================================");
      }

    } catch (XPathExpressionException e) {
      e.printStackTrace();
    }
  }
Example #18
0
  public static void readXpath()
      throws ParserConfigurationException, SAXException, IOException, XPathExpressionException {

    DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
    domFactory.setNamespaceAware(true);
    DocumentBuilder builder = domFactory.newDocumentBuilder();
    Document doc = builder.parse("D:\\temp\\test_2\\screen_2.xml");
    XPath xpath = XPathFactory.newInstance().newXPath();
    // XPath Query for showing all nodes value
    // XPathExpression expr = xpath
    // .compile("//Screens/Screen[@number='1']/Button[@number='1']/Action[@type='onclick']/*");
    String xpathStr = "//Screen[@number='2007']/Button[@number='87'][@h='1']";
    XPathExpression expr = xpath.compile(xpathStr);

    Object result = expr.evaluate(doc, XPathConstants.NODESET);
    NodeList nodes = (NodeList) result;
    for (int i = 0; i < nodes.getLength(); i++) {
      NamedNodeMap nodeMap = nodes.item(i).getAttributes();
      String attrName = "";
      for (int j = 0; j < nodeMap.getLength(); j++) {
        attrName = xpathStr.substring(xpathStr.lastIndexOf('@') + 1, xpathStr.lastIndexOf("="));
        if (nodes.item(i).getAttributes().item(j).getNodeName().equals(attrName)) {
          System.out.println(nodes.item(i).getAttributes().item(j).getNodeValue());
        }
      }
    }
  }
Example #19
0
 /**
  * Evaluate an XPath string and return true if the output is to be included or not.
  *
  * @param contextNode The node to start searching from.
  * @param xpathnode The XPath node
  * @param str The XPath expression
  * @param namespaceNode The node from which prefixes in the XPath will be resolved to namespaces.
  */
 public boolean evaluate(Node contextNode, Node xpathnode, String str, Node namespaceNode)
     throws TransformerException {
   if (!str.equals(xpathStr) || xpathExpression == null) {
     if (xpf == null) {
       xpf = XPathFactory.newInstance();
       try {
         xpf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
       } catch (XPathFactoryConfigurationException ex) {
         throw new TransformerException(ex);
       }
     }
     XPath xpath = xpf.newXPath();
     xpath.setNamespaceContext(new DOMNamespaceContext(namespaceNode));
     xpathStr = str;
     try {
       xpathExpression = xpath.compile(xpathStr);
     } catch (XPathExpressionException ex) {
       throw new TransformerException(ex);
     }
   }
   try {
     return (Boolean) xpathExpression.evaluate(contextNode, XPathConstants.BOOLEAN);
   } catch (XPathExpressionException ex) {
     throw new TransformerException(ex);
   }
 }
Example #20
0
  public static void main(String[] args)
      throws ParserConfigurationException, SAXException, IOException, XPathExpressionException,
          TransformerFactoryConfigurationError, TransformerException {
    DocumentBuilder bud = DocumentBuilderFactory.newInstance().newDocumentBuilder();

    InputStream inp = new ByteArrayInputStream(xml.getBytes());

    Document doc = bud.parse(inp);

    XPath xpath = XPathFactory.newInstance().newXPath();
    XPathExpression expr = xpath.compile("//Person/PostalCode");

    NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);

    for (int i = 0; i < nodes.getLength(); i++) {
      System.out.println(nodes.item(i).getTextContent());
      nodes.item(i).setTextContent("Ala ma kota " + i);
    }

    Transformer xformer = TransformerFactory.newInstance().newTransformer();
    StringWriter bufor = new StringWriter();
    xformer.transform(new DOMSource(doc), new StreamResult(bufor));
    System.out.println("===================");
    System.out.println(bufor.toString());
  }
  private String fromXmlToColor(String xml) {
    String result = BLUE;
    DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
    domFactory.setNamespaceAware(true); // never forget this!
    DocumentBuilder builder = null;
    try {
      builder = domFactory.newDocumentBuilder();

      Document document = builder.parse(new InputSource(new StringReader(xml)));

      XPathFactory factory = XPathFactory.newInstance();
      XPath xpath = factory.newXPath();
      XPathExpression expr = xpath.compile("//color");

      Object n = expr.evaluate(document, XPathConstants.NODESET);
      NodeList nodes = (NodeList) n;
      if (nodes.getLength() > 0) {
        result = (String) nodes.item(0).getTextContent();
      }

    } catch (Exception e) {
      System.err.println("fromXmlToColor:" + e);
    }
    return result;
  }
  public NodeList getHeaderRows() throws Exception {
    DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
    // docFactory.setNamespaceAware(true);
    DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
    Document doc = docBuilder.parse(file);

    NodeList sheetLst = doc.getElementsByTagName("ss:Name");

    XPath xpath = XPathFactory.newInstance().newXPath();
    XPathExpression expr =
        xpath.compile("//Worksheet[@Name=\"" + sheetName + "\"]/Table/Row[1]/Cell");
    Object result = expr.evaluate(doc, XPathConstants.NODESET);
    NodeList headerNodes = (NodeList) result;

    Node toRem = (Node) headerNodes.item(0);
    for (int i = 0; i < sheetLst.getLength(); i++) {
      List lstFields = new ArrayList<Node>();
      List lstFields_common = new ArrayList<Node>();
      log.debug("======================start=======================");
      Node testSuiteNode = sheetLst.item(i);
      NamedNodeMap commonAttributesList = testSuiteNode.getAttributes();
    }

    return headerNodes;
  }
Example #23
0
  public Object resolveReference(
      Object referencedObject,
      Node elementWithReference,
      String referenceString,
      Map<String, Object> referencedObjects,
      List<ForwardReferences> forwardRefs)
      throws XPathExpressionException, IllegalArgumentException, SecurityException,
          InstantiationException, IllegalAccessException, InvocationTargetException,
          NoSuchMethodException, ParseException {
    XPathExpression exp = xpath.compile(referenceString);
    Log.i("resolveRef", "xpath evaluated for :" + referenceString);
    Element refferredElement = (Element) exp.evaluate(elementWithReference, XPathConstants.NODE);
    if (refferredElement == null) {
      throw new ParseException("Element by reference not found");
    }
    String xpathFromRoot = ParserUtil.getElementXpath(refferredElement);
    Object object = referencedObjects.get(xpathFromRoot);
    if (object == null) {
      referencedObject = objectGetter.getobjectOfClass(referencedObject.getClass(), "");
      ForwardReferences forwardRef = new ForwardReferences(referencedObject, xpathFromRoot, null);
      forwardRefs.add(forwardRef);

    } else {
      referencedObject = object;
    }
    return referencedObject;
  }
  public NodeList getOQasNodeList()
      throws SAXException, ParserConfigurationException, XPathExpressionException {
    NodeList result = null;
    if (oqUrl == null) {
      logger.warn("OQ.url not found. Synchronization impossible.");
      trace.append("Синхронизация невозможна: OQ.url не указан.");
      return result;
    }
    try {
      URLConnection oqc = oqUrl.openConnection();
      DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
      domFactory.setNamespaceAware(true);
      DocumentBuilder builder = domFactory.newDocumentBuilder();
      Document doc = builder.parse(oqc.getInputStream());
      XPath xpath = XPathFactory.newInstance().newXPath();
      XPathExpression expr = xpath.compile("/root/projects/project");
      result = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
    } catch (IOException e) { // обрабатываем только IOException - остальные выбрасываем наверх
      logger.error("oq project sync error: ", e);
      trace
          .append(
              "Синхронизация прервана из-за ошибки ввода/вывода при попытке получить и прочитать файл "
                  + "синхронизации: ")
          .append(e.getMessage())
          .append("\n");
    }

    return result;
  }
 @Override
 public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
   super.visitMethodCallExpression(expression);
   final PsiExpressionList argumentList = expression.getArgumentList();
   final PsiExpression[] arguments = argumentList.getExpressions();
   if (arguments.length == 0) {
     return;
   }
   final PsiExpression xpathArgument = arguments[0];
   if (!ExpressionUtils.hasStringType(xpathArgument)) {
     return;
   }
   if (!PsiUtil.isConstantExpression(xpathArgument)) {
     return;
   }
   final PsiType type = xpathArgument.getType();
   if (type == null) {
     return;
   }
   final String value = (String) ConstantExpressionUtil.computeCastTo(xpathArgument, type);
   if (value == null) {
     return;
   }
   if (!callTakesXPathExpression(expression)) {
     return;
   }
   final XPathFactory xpathFactory = XPathFactory.newInstance();
   final XPath xpath = xpathFactory.newXPath();
   //noinspection UnusedCatchParameter,ProhibitedExceptionCaught
   try {
     xpath.compile(value);
   } catch (XPathExpressionException ignore) {
     registerError(xpathArgument);
   }
 }
Example #26
0
  public String extractInfoObjectIdentifier(String infoObjectResponse) {

    String reportId = null;

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    // dbf.setNamespaceAware(true);
    try {
      DocumentBuilder db = dbf.newDocumentBuilder();
      Document doc = db.parse(new ByteArrayInputStream(infoObjectResponse.getBytes("UTF-8")));

      XPathFactory factory = XPathFactory.newInstance();
      XPath xpath = factory.newXPath();
      XPathExpression expr = xpath.compile("//info-object");
      Object result = expr.evaluate(doc, XPathConstants.NODESET);

      NodeList nodes = (NodeList) result;
      Node item = nodes.item(0);
      if (item != null) {
        NamedNodeMap attributesMap = item.getAttributes();
        Node idAttribute = attributesMap.getNamedItem("id");
        reportId = idAttribute.getNodeValue();
      }

    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } catch (XPathExpressionException e) {
      e.printStackTrace();
    }

    return reportId;
  }
 private void checkBomVersionInPom(String xml) {
   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
   DocumentBuilder builder;
   Document doc = null;
   try {
     builder = factory.newDocumentBuilder();
     doc = builder.parse(new InputSource(new StringReader(xml)));
   } catch (SAXException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (ParserConfigurationException e1) {
     // TODO Auto-generated catch block
     e1.printStackTrace();
   }
   XPathFactory xPathfactory = XPathFactory.newInstance();
   XPath xpath = xPathfactory.newXPath();
   XPathExpression expr = null;
   String bom_version = null;
   try {
     expr = xpath.compile("/project/properties/version.jboss.bom");
     bom_version = (String) expr.evaluate(doc, XPathConstants.STRING);
   } catch (XPathExpressionException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   assertEquals(
       "jboss bom version in pom differs from the one given by wizard", version, bom_version);
 }
Example #28
0
	public NodeList запросNodes(String запрос) throws XPathExpressionException {

		XPathExpression выражение;
		выражение = xPath.compile(запрос);
		return (NodeList) выражение.evaluate(документ.getDocumentElement(),
				XPathConstants.NODESET);
	}
  public List<String> getNodeDetails(NamespaceContext nsc, String exprString, String filePath)
      throws XPathExpressionException {

    List<String> list = new ArrayList<String>();
    XPathFactory factory = XPathFactory.newInstance();

    // 2. Use the XPathFactory to create a new XPath object
    XPath xpath = factory.newXPath();

    xpath.setNamespaceContext(nsc);

    // 3. Compile an XPath string into an XPathExpression
    XPathExpression expression = xpath.compile(exprString);

    // 4. Evaluate the XPath expression on an input document
    Node result =
        (Node) expression.evaluate(new org.xml.sax.InputSource(filePath), XPathConstants.NODE);

    String svcName = null;
    NamedNodeMap attMap = result.getAttributes();
    Node att = attMap.getNamedItem("group");
    if (att != null) svcName = att.getNodeValue();
    if (result != null) {
      list.add(result.getNodeName());
      list.add(result.getTextContent());
      list.add(svcName);
    }
    factory = null;
    xpath = null;
    expression = null;
    result = null;
    attMap = null;
    att = null;
    return list;
  }
Example #30
0
	public Double запрос„исла(String запрос) throws XPathExpressionException {

		XPathExpression выражение;
		выражение = xPath.compile(запрос);
		return (Double) выражение.evaluate(документ.getDocumentElement(),
				XPathConstants.NUMBER);
	}