protected Element copyElementToName(Element element, String tagName) {
   Element newElement = element.getOwnerDocument().createElement(tagName);
   NamedNodeMap attrs = element.getAttributes();
   for (int i = 0; i < attrs.getLength(); i++) {
     Node attribute = attrs.item(i);
     newElement.setAttribute(attribute.getNodeName(), attribute.getNodeValue());
   }
   for (int i = 0; i < element.getChildNodes().getLength(); i++) {
     newElement.appendChild(element.getChildNodes().item(i).cloneNode(true));
   }
   return newElement;
 }
Beispiel #2
0
  private void processFilter(Session session, Element element, HashMap additionalInformation) {

    String match = getAttribute(element, SessionAttribute.FILTER_MATCH.getText());
    String showAllTracks = getAttribute(element, SessionAttribute.FILTER_SHOW_ALL_TRACKS.getText());

    String filterName = getAttribute(element, SessionAttribute.NAME.getText());
    TrackFilter filter = new TrackFilter(filterName, null);
    additionalInformation.put(SessionElement.FILTER, filter);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);

    // Save the filter
    session.setFilter(filter);

    // Set filter properties
    if ("all".equalsIgnoreCase(match)) {
      IGV.getInstance().setFilterMatchAll(true);
    } else if ("any".equalsIgnoreCase(match)) {
      IGV.getInstance().setFilterMatchAll(false);
    }

    if ("true".equalsIgnoreCase(showAllTracks)) {
      IGV.getInstance().setFilterShowAllTracks(true);
    } else {
      IGV.getInstance().setFilterShowAllTracks(false);
    }
  }
Beispiel #3
0
  private void processPanel(Session session, Element element, HashMap additionalInformation) {
    panelElementPresent = true;
    String panelName = element.getAttribute("name");
    if (panelName == null) {
      panelName = "Panel" + panelCounter++;
    }

    List<Track> panelTracks = new ArrayList();
    NodeList elements = element.getChildNodes();
    for (int i = 0; i < elements.getLength(); i++) {
      Node childNode = elements.item(i);
      if (childNode.getNodeName().equalsIgnoreCase(SessionElement.DATA_TRACK.getText())
          || // Is this a track?
          childNode.getNodeName().equalsIgnoreCase(SessionElement.TRACK.getText())) {

        List<Track> tracks = processTrack(session, (Element) childNode, additionalInformation);
        if (tracks != null) {
          panelTracks.addAll(tracks);
        }
      } else {
        process(session, childNode, additionalInformation);
      }
    }

    TrackPanel panel = IGV.getInstance().getTrackPanel(panelName);
    panel.addTracks(panelTracks);
  }
Beispiel #4
0
  public static Element[] filterChildElements(Element parent, String ns, String lname) {
    /*
    way too noisy
            if (LOGGER.isDebugEnabled()) {
                StringBuilder buf = new StringBuilder(100);
                buf.append("XmlaUtil.filterChildElements: ");
                buf.append(" ns=\"");
                buf.append(ns);
                buf.append("\", lname=\"");
                buf.append(lname);
                buf.append("\"");
                LOGGER.debug(buf.toString());
            }
    */

    List<Element> elems = new ArrayList<Element>();
    NodeList nlst = parent.getChildNodes();
    for (int i = 0, nlen = nlst.getLength(); i < nlen; i++) {
      Node n = nlst.item(i);
      if (n instanceof Element) {
        Element e = (Element) n;
        if ((ns == null || ns.equals(e.getNamespaceURI()))
            && (lname == null || lname.equals(e.getLocalName()))) {
          elems.add(e);
        }
      }
    }
    return elems.toArray(new Element[elems.size()]);
  }
  public IXArchElement cloneElement(int depth) {
    synchronized (DOMUtils.getDOMLock(elt)) {
      Document doc = elt.getOwnerDocument();
      if (depth == 0) {
        Element cloneElt = (Element) elt.cloneNode(false);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());
        return cloneImpl;
      } else if (depth == 1) {
        Element cloneElt = (Element) elt.cloneNode(false);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());

        NodeList nl = elt.getChildNodes();
        int size = nl.getLength();
        for (int i = 0; i < size; i++) {
          Node n = nl.item(i);
          Node cloneNode = (Node) n.cloneNode(false);
          cloneNode = doc.importNode(cloneNode, true);
          cloneElt.appendChild(cloneNode);
        }
        return cloneImpl;
      } else /* depth = infinity */ {
        Element cloneElt = (Element) elt.cloneNode(true);
        cloneElt = (Element) doc.importNode(cloneElt, true);
        AbstractChangeSetImpl cloneImpl = new AbstractChangeSetImpl(cloneElt);
        cloneImpl.setXArch(getXArch());
        return cloneImpl;
      }
    }
  }
Beispiel #6
0
  private void processColorScale(Session session, Element element, HashMap additionalInformation) {

    String trackType = getAttribute(element, SessionAttribute.TYPE.getText());
    String value = getAttribute(element, SessionAttribute.VALUE.getText());

    setColorScaleSet(session, trackType, value);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);
  }
Beispiel #7
0
 /** @deprecated use allText(Element elem, boolean trim) */
 public static String allTextFromElement(Element elem, boolean trim) throws DOMException {
   StringBuffer textBuf = new StringBuffer();
   NodeList nl = elem.getChildNodes();
   for (int j = 0, len = nl.getLength(); j < len; ++j) {
     Node node = nl.item(j);
     if (node instanceof Text) // includes Text and CDATA!
     textBuf.append(node.getNodeValue());
   }
   String out = textBuf.toString();
   return (trim ? out.trim() : out);
 }
Beispiel #8
0
  private void processPreferences(Session session, Element element, HashMap additionalInformation) {

    NodeList elements = element.getChildNodes();
    for (int i = 0; i < elements.getLength(); i++) {
      Node child = elements.item(i);
      if (child.getNodeName().equalsIgnoreCase(SessionElement.PROPERTY.getText())) {
        Element childNode = (Element) child;
        String name = getAttribute(childNode, SessionAttribute.NAME.getText());
        String value = getAttribute(childNode, SessionAttribute.VALUE.getText());
        session.setPreference(name, value);
      }
    }
  }
Beispiel #9
0
 public static String textInElement(Element elem) {
   StringBuilder buf = new StringBuilder(100);
   elem.normalize();
   NodeList nlst = elem.getChildNodes();
   for (int i = 0, nlen = nlst.getLength(); i < nlen; i++) {
     Node n = nlst.item(i);
     if (n instanceof Text) {
       final String data = ((Text) n).getData();
       buf.append(data);
     }
   }
   return buf.toString();
 }
Beispiel #10
0
  private void processRegion(Session session, Element element, HashMap additionalInformation) {

    String chromosome = getAttribute(element, SessionAttribute.CHROMOSOME.getText());
    String start = getAttribute(element, SessionAttribute.START_INDEX.getText());
    String end = getAttribute(element, SessionAttribute.END_INDEX.getText());
    String description = getAttribute(element, SessionAttribute.DESCRIPTION.getText());

    RegionOfInterest region =
        new RegionOfInterest(chromosome, new Integer(start), new Integer(end), description);
    IGV.getInstance().addRegionOfInterest(region);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);
  }
Beispiel #11
0
  @Test
  public void testNodeValueOnTextNode() throws Exception {
    String xml =
        "<?xml version=\"1.0\"?>" + "<root>" + "  <property>Hello World</property>" + "</root>";

    //    builderFactory = DocumentBuilderFactory.newInstance();
    builderFactory.setNamespaceAware(true);

    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    Document doc = builder.parse(Utils.createInputSource(xml));
    Element root = doc.getDocumentElement();
    NodeList list = root.getChildNodes();
    for (int i = 0; i < list.getLength(); i++) {
      Node node = list.item(i);
      if (node instanceof Element) {
        Element elem = (Element) node;
        Node textNode = elem.getChildNodes().item(0);
        Assert.assertEquals(
            "Text.getNodeValue", textNode.getNodeValue(), textNode.getTextContent());
        return;
      }
    }
    Assert.assertEquals("Text.getNodeValue", true, false);
  }
Beispiel #12
0
  /**
   * Searches the children of an element looking for a Text node. If it finds one, it returns it.
   *
   * @param element The element whose children will be searched
   * @return The text for the element, or null if there is none
   */
  public static String getElementString(Element element) {
    NodeList nodes = element.getChildNodes();

    int numNodes = nodes.getLength();

    for (int i = 0; i < numNodes; i++) {
      Node node = nodes.item(i);

      if (node instanceof Text) {
        return ((Text) node).getData();
      }
    }

    return null;
  }
  public void validateContent(IProgressMonitor monitor) {
    Element element = getDocumentRoot();
    if (element == null) return;
    String elementName = element.getNodeName();
    if (!"plugin".equals(elementName)
        && !"fragment".equals(elementName)) { // $NON-NLS-1$ //$NON-NLS-2$
      reportIllegalElement(element, CompilerFlags.ERROR);
    } else {
      int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_DEPRECATED);
      if (severity != CompilerFlags.IGNORE) {
        NamedNodeMap attrs = element.getAttributes();
        for (int i = 0; i < attrs.getLength(); i++) {
          reportUnusedAttribute(element, attrs.item(i).getNodeName(), severity);
        }
      }

      NodeList children = element.getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        if (monitor.isCanceled()) break;
        Element child = (Element) children.item(i);
        String name = child.getNodeName();
        if (name.equals("extension")) { // $NON-NLS-1$
          validateExtension(child);
        } else if (name.equals("extension-point")) { // $NON-NLS-1$
          validateExtensionPoint(child);
        } else {
          if (!name.equals("runtime") && !name.equals("requires")) { // $NON-NLS-1$ //$NON-NLS-2$
            severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ELEMENT);
            if (severity != CompilerFlags.IGNORE) reportIllegalElement(child, severity);
          } else {
            severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_DEPRECATED);
            if (severity != CompilerFlags.IGNORE) reportUnusedElement(child, severity);
          }
        }
      }

      IExtensions extensions = fModel.getExtensions();
      if (extensions != null
          && extensions.getExtensions().length == 0
          && extensions.getExtensionPoints().length == 0)
        report(
            MDECoreMessages.Builders_Manifest_useless_file,
            -1,
            IMarker.SEVERITY_WARNING,
            MDEMarkerFactory.P_USELESS_FILE,
            MDEMarkerFactory.CAT_OTHER);
    }
  }
Beispiel #14
0
  private void processHiddenAttributes(
      Session session, Element element, HashMap additionalInformation) {

    //        session.clearRegionsOfInterest();
    NodeList elements = element.getChildNodes();
    if (elements.getLength() > 0) {
      Set<String> attributes = new HashSet();
      for (int i = 0; i < elements.getLength(); i++) {
        Node childNode = elements.item(i);
        if (childNode.getNodeName().equals(IGVSessionReader.SessionElement.ATTRIBUTE.getText())) {
          attributes.add(
              ((Element) childNode).getAttribute(IGVSessionReader.SessionAttribute.NAME.getText()));
        }
      }
      session.setHiddenAttributes(attributes);
    }
  }
  protected static XmlConfigurator parse(Element root_element) throws java.io.IOException {
    XmlConfigurator configurator = null;
    final LinkedList<ProtocolConfiguration> prot_data = new LinkedList<ProtocolConfiguration>();

    /**
     * CAUTION: crappy code ahead ! I (bela) am not an XML expert, so the code below is pretty
     * amateurish... But it seems to work, and it is executed only on startup, so no perf loss on
     * the critical path. If somebody wants to improve this, please be my guest.
     */
    try {
      String root_name = root_element.getNodeName();
      if (!"config".equals(root_name.trim().toLowerCase()))
        throw new IOException("the configuration does not start with a <config> element");

      NodeList prots = root_element.getChildNodes();
      for (int i = 0; i < prots.getLength(); i++) {
        Node node = prots.item(i);
        if (node.getNodeType() != Node.ELEMENT_NODE) continue;

        Element tag = (Element) node;
        String protocol = tag.getTagName();
        Map<String, String> params = new HashMap<String, String>();

        NamedNodeMap attrs = tag.getAttributes();
        int attrLength = attrs.getLength();
        for (int a = 0; a < attrLength; a++) {
          Attr attr = (Attr) attrs.item(a);
          String name = attr.getName();
          String value = attr.getValue();
          params.put(name, value);
        }
        ProtocolConfiguration cfg = new ProtocolConfiguration(protocol, params);
        prot_data.add(cfg);
      }
      configurator = new XmlConfigurator(prot_data);
    } catch (Exception x) {
      if (x instanceof java.io.IOException) throw (java.io.IOException) x;
      else {
        IOException tmp = new IOException();
        tmp.initCause(x);
        throw tmp;
      }
    }
    return configurator;
  }
  /** extracts XML from PDF */
  protected byte[] getXMLFromPDF(PdfReader reader) throws Exception {
    XfaForm xfaForm = reader.getAcroFields().getXfa();
    Node domDocument = xfaForm.getDomDocument();
    if (domDocument == null) return null;
    Element documentElement = ((Document) domDocument).getDocumentElement();

    Element datasetsElement =
        (Element) documentElement.getElementsByTagNameNS(XFA_NS, "datasets").item(0);
    Element dataElement = (Element) datasetsElement.getElementsByTagNameNS(XFA_NS, "data").item(0);

    Element xmlElement = (Element) dataElement.getChildNodes().item(0);

    Node budgetElement = getBudgetElement(xmlElement);

    byte[] serializedXML = XfaForm.serializeDoc(budgetElement);

    return serializedXML;
  }
Beispiel #17
0
  @Test
  public void testgetAttributesWithNamedNodeMap() throws Exception {
    //		builderFactory = DocumentBuilderFactory.newInstance();
    builderFactory.setNamespaceAware(true);

    File f = new File(System.getProperty("user.dir"), "src/test/resources/sample-springbeans.xml");
    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    Document doc = builder.parse(f);
    Element root = doc.getDocumentElement();
    //		System.out.println("* current impl:  " + doc.getClass().getName());

    // id, class
    Map<String, String> actualMap = new HashMap<String, String>();

    NodeList list = root.getChildNodes();
    for (int i = 0; i < list.getLength(); i++) {
      Node node = list.item(i);
      if (node instanceof Element) {
        Element elem = (Element) node;
        if (elem.getTagName().equals("beans:bean")) {
          //					System.out.println("bean[" + elem.getAttribute("id") + "]");
          NamedNodeMap map = elem.getAttributes();
          String valueId = null;
          String valueClass = null;
          for (int x = 0; x < map.getLength(); x++) {
            Node attr = map.item(x);
            if (attr.getNodeName().equals("id")) valueId = attr.getNodeValue();
            if (attr.getNodeName().equals("class")) valueClass = attr.getNodeValue();
          }
          if (valueId != null && valueClass != null) actualMap.put(valueId, valueClass);
        }
      }
    }

    Map<String, String> expected = new HashMap<String, String>();
    expected.put("authenticationManager", "org.springframework.security.providers.ProviderManager");
    expected.put(
        "daoAuthenticationProvider",
        "org.springframework.security.providers.dao.DaoAuthenticationProvider");
    expected.put(
        "loggerListener", "org.springframework.security.event.authentication.LoggerListener");
    Assert.assertEquals("Attributes with NamedNodeMap", expected, actualMap);
  }
Beispiel #18
0
 JdbcIndexDefinition(
     DataSource ds,
     Element element,
     Set allIndexedFields,
     boolean storeText,
     boolean mergeText,
     Analyzer a,
     boolean isSub) {
   this.dataSource = ds;
   indexSql = element.getAttribute("sql");
   key = element.getAttribute("key");
   String elementId = element.getAttribute("identifier");
   identifier = "".equals(elementId) ? key : elementId;
   findSql = element.getAttribute("find");
   NodeList childNodes = element.getChildNodes();
   for (int k = 0; k < childNodes.getLength(); k++) {
     if (childNodes.item(k) instanceof Element) {
       Element childElement = (Element) childNodes.item(k);
       if ("field".equals(childElement.getLocalName())) {
         if (childElement.getAttribute("keyword").equals("true")) {
           keyWords.add(childElement.getAttribute("name"));
         }
         String m = childElement.getAttribute("multiple");
         if ("".equals(m)) m = "add";
         if (!m.equals("add")) {
           nonDefaultMultiples.put(
               childElement.getAttribute("name"), Indexer.Multiple.valueOf(m.toUpperCase()));
         }
         String b = childElement.getAttribute("boost");
         if (!b.equals("")) {
           boosts.put(childElement.getAttribute("name"), Float.valueOf(b));
         }
       } else if ("related".equals(childElement.getLocalName())) {
         subQueries.add(
             new JdbcIndexDefinition(
                 ds, childElement, allIndexedFields, storeText, mergeText, a, true));
       }
     }
   }
   this.analyzer = a;
   this.isSub = isSub;
   assert !isSub || "".equals(findSql);
 }
Beispiel #19
0
  private void processFrames(Element element) {
    NodeList elements = element.getChildNodes();
    if (elements.getLength() > 0) {
      Map<String, ReferenceFrame> frames = new HashMap();
      for (ReferenceFrame f : FrameManager.getFrames()) {
        frames.put(f.getName(), f);
      }
      List<ReferenceFrame> reorderedFrames = new ArrayList();

      for (int i = 0; i < elements.getLength(); i++) {
        Node childNode = elements.item(i);
        if (childNode.getNodeName().equalsIgnoreCase(SessionElement.FRAME.getText())) {
          String frameName = getAttribute((Element) childNode, SessionAttribute.NAME.getText());

          ReferenceFrame f = frames.get(frameName);
          if (f != null) {
            reorderedFrames.add(f);
            try {
              String chr = getAttribute((Element) childNode, SessionAttribute.CHR.getText());
              final String startString =
                  getAttribute((Element) childNode, SessionAttribute.START.getText())
                      .replace(",", "");
              final String endString =
                  getAttribute((Element) childNode, SessionAttribute.END.getText())
                      .replace(",", "");
              int start = ParsingUtils.parseInt(startString);
              int end = ParsingUtils.parseInt(endString);
              org.broad.igv.feature.Locus locus = new Locus(chr, start, end);
              f.jumpTo(locus);
            } catch (NumberFormatException e) {
              e.printStackTrace(); // To change body of catch statement use File | Settings |
              // File Templates.
            }
          }
        }
      }
      if (reorderedFrames.size() > 0) {
        FrameManager.setFrames(reorderedFrames);
      }
    }
    IGV.getInstance().resetFrames();
  }
Beispiel #20
0
  /**
   * This interface method is called to set all the fieldValues of this object of <code>InPort
   * </code>, using the specified XML string.
   *
   * @param port The new fieldValues value
   * @exception FioranoException if an error occurs while parsing the XMLString
   * @since Tifosi2.0
   */
  public void setFieldValues(Element port) throws FioranoException {
    //        Document doc = XMLUtils.getDOMDocumentFromXML(xmlString);
    //        Element port = doc.getDocumentElement();

    if (port != null) {
      m_bIsSyncRequestType = XMLDmiUtil.getAttributeAsBoolean(port, "isSyncRequestType");

      NodeList children = port.getChildNodes();
      Node child = null;

      for (int i = 0; children != null && i < children.getLength(); ++i) {
        child = children.item(i);

        String nodeName = child.getNodeName();

        if (nodeName.equalsIgnoreCase("Name")) {
          m_strPortName = XMLUtils.getNodeValueAsString(child).toUpperCase();
        }

        if (nodeName.equalsIgnoreCase("Description")) {
          m_strDscription = XMLUtils.getNodeValueAsString(child);
        }

        if (nodeName.equalsIgnoreCase("XSD")) {
          m_strXSD = XMLUtils.getNodeValueAsString(child);
        }

        if (nodeName.equalsIgnoreCase("JavaClass")) {
          m_strJavaClass = XMLUtils.getNodeValueAsString(child);
        }

        if (nodeName.equalsIgnoreCase("Param")) {
          Param paramDmi = new Param();

          paramDmi.setFieldValues((Element) child);
          addParam(paramDmi);
        }
      }
    }
    validate();
  }
Beispiel #21
0
  private void processFilterElement(
      Session session, Element element, HashMap additionalInformation) {

    TrackFilter filter = (TrackFilter) additionalInformation.get(SessionElement.FILTER);
    String item = getAttribute(element, SessionAttribute.ITEM.getText());
    String operator = getAttribute(element, SessionAttribute.OPERATOR.getText());
    String value = getAttribute(element, SessionAttribute.VALUE.getText());
    String booleanOperator = getAttribute(element, SessionAttribute.BOOLEAN_OPERATOR.getText());

    TrackFilterElement trackFilterElement =
        new TrackFilterElement(
            filter,
            item,
            Operator.findEnum(operator),
            value,
            BooleanOperator.findEnum(booleanOperator));
    filter.add(trackFilterElement);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);
  }
Beispiel #22
0
  private static Vector<Annotation> parseAnnotations(Node parent) throws XmlParserException {
    Vector<Annotation> annotations = new Vector<Annotation>();

    NodeList nodes = parent.getChildNodes();
    for (int nodeid = 0; nodeid < nodes.getLength(); ++nodeid) {
      Node node = nodes.item(nodeid);
      if (node.getNodeType() != Node.ELEMENT_NODE) continue;

      Element element = (Element) node;
      if (element.getTagName().equals("annotation")) {
        String label = null, value = null, valuetype = null, unit = null;
        NodeList annotation_nodes = element.getChildNodes();
        for (int annotationid = 0; annotationid < annotation_nodes.getLength(); ++annotationid) {
          Node annotation_node = annotation_nodes.item(annotationid);
          if (annotation_node.getNodeType() != Node.ELEMENT_NODE) continue;

          Element annotation_element = (Element) annotation_node;
          if (annotation_element.getTagName().equals("label"))
            label = annotation_element.getTextContent();
          else if (annotation_element.getTagName().equals("value"))
            value = annotation_element.getTextContent();
          else if (annotation_element.getTagName().equals("valuetype"))
            valuetype = annotation_element.getTextContent();
        }

        if (label == null || value == null || valuetype == null)
          throw new XmlParserException("Annotation is missing either: label, value or valuetype");

        Annotation annotation =
            new Annotation(label, value, Annotation.ValueType.valueOf(valuetype));
        annotation.setUnit(unit);
        if (annotation.getValueType() == Annotation.ValueType.ONTOLOGY)
          annotation.setOntologyRef(element.getAttribute("ontologyref"));
        if (element.getAttribute("unit") != null) annotation.setUnit(element.getAttribute("unit"));
        annotations.add(annotation);
      }
    }

    return annotations;
  }
Beispiel #23
0
  /**
   * Reads the children of an XML element and matches them to properties of a bean.
   *
   * @param ob The bean to receive the values
   * @param element The element the corresponds to the bean
   * @throws IOException If there is an error reading the document
   */
  public void readObject(Object ob, Element element) throws IOException {
    // If the object is null, skip the element
    if (ob == null) {
      return;
    }

    try {
      BeanInfo info = (BeanInfo) beanCache.get(ob.getClass());

      if (info == null) {
        // Get the bean info for the object
        info = Introspector.getBeanInfo(ob.getClass(), Object.class);

        beanCache.put(ob.getClass(), info);
      }

      // Get the object's properties
      PropertyDescriptor[] props = info.getPropertyDescriptors();

      // Get the attributes of the node
      NamedNodeMap attrs = element.getAttributes();

      // Get the children of the XML element
      NodeList nodes = element.getChildNodes();

      int numNodes = nodes.getLength();

      for (int i = 0; i < props.length; i++) {
        // Treat indexed properties a little differently
        if (props[i] instanceof IndexedPropertyDescriptor) {
          readIndexedProperty(ob, (IndexedPropertyDescriptor) props[i], nodes, attrs);
        } else {
          readProperty(ob, props[i], nodes, attrs);
        }
      }
    } catch (IntrospectionException exc) {
      throw new IOException(
          "Error getting bean info for " + ob.getClass().getName() + ": " + exc.toString());
    }
  }
Beispiel #24
0
 private static NodeList getChildElements(Element self, String elementName) {
   List result = new ArrayList();
   NodeList nodeList = self.getChildNodes();
   for (int i = 0; i < nodeList.getLength(); i++) {
     Node node = nodeList.item(i);
     if (node.getNodeType() == Node.ELEMENT_NODE) {
       Element child = (Element) node;
       if ("*".equals(elementName) || child.getTagName().equals(elementName)) {
         result.add(child);
       }
     } else if (node.getNodeType() == Node.TEXT_NODE) {
       String value = node.getNodeValue();
       if (trimWhitespace) {
         value = value.trim();
       }
       if ("*".equals(elementName) && value.length() > 0) {
         node.setNodeValue(value);
         result.add(node);
       }
     }
   }
   return new NodesHolder(result);
 }
Beispiel #25
0
  @Test
  public void testAddText() throws Exception {
    //		builderFactory = DocumentBuilderFactory.newInstance();
    builderFactory.setNamespaceAware(true);

    String xml =
        "<?xml version=\"1.0\"?>"
            + "<root>"
            + "<item id=\"a\"/>"
            + "<child id=\"1\"/>"
            + "<item id=\"b\"/>"
            + "<child id=\"2\"/>"
            + "</root>";

    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes()));
    Element root = doc.getDocumentElement();
    Text text = doc.createTextNode("hello world");
    root.insertBefore(text, root.getFirstChild().getNextSibling());

    Assert.assertEquals(
        "append text", "hello world", root.getChildNodes().item(1).getTextContent());
  }
Beispiel #26
0
  /**
   * For backward compatibility
   *
   * @param session
   * @param element
   * @param additionalInformation
   */
  private void processVisibleAttributes(
      Session session, Element element, HashMap additionalInformation) {

    //        session.clearRegionsOfInterest();
    NodeList elements = element.getChildNodes();
    if (elements.getLength() > 0) {
      Set<String> visibleAttributes = new HashSet();
      for (int i = 0; i < elements.getLength(); i++) {
        Node childNode = elements.item(i);
        if (childNode
            .getNodeName()
            .equals(IGVSessionReader.SessionElement.VISIBLE_ATTRIBUTE.getText())) {
          visibleAttributes.add(
              ((Element) childNode).getAttribute(IGVSessionReader.SessionAttribute.NAME.getText()));
        }
      }

      final List<String> attributeNames = AttributeManager.getInstance().getAttributeNames();
      Set<String> hiddenAttributes = new HashSet<String>(attributeNames);
      hiddenAttributes.removeAll(visibleAttributes);
      session.setHiddenAttributes(hiddenAttributes);
    }
  }
  private void validateRequiredExtensionAttributes(Element element, ISchemaElement schemaElement) {
    int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_NO_REQUIRED_ATT);
    if (severity == CompilerFlags.IGNORE) return;

    ISchemaAttribute[] attInfos = schemaElement.getAttributes();
    for (int i = 0; i < attInfos.length; i++) {
      ISchemaAttribute attInfo = attInfos[i];
      if (attInfo.getUse() == ISchemaAttribute.REQUIRED) {
        boolean found = element.getAttributeNode(attInfo.getName()) != null;
        if (!found && attInfo.getKind() == IMetaAttribute.JAVA) {
          NodeList children = element.getChildNodes();
          for (int j = 0; j < children.getLength(); j++) {
            if (attInfo.getName().equals(children.item(j).getNodeName())) {
              found = true;
              break;
            }
          }
        }
        if (!found) {
          reportMissingRequiredAttribute(element, attInfo.getName(), severity);
        }
      }
    }
  }
Beispiel #28
0
  @Test
  public void loopCheckElementNameAndAttribute()
      throws ParserConfigurationException, IOException, SAXException {
    //		builderFactory = DocumentBuilderFactory.newInstance();
    String xml =
        "<?xml version=\"1.0\"?>"
            + "<root>"
            + "<item name=\"a\" />"
            + "<item name=\"b\" />"
            + "<item name=\"c\" />"
            + "</root>";

    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes()));
    Element root = doc.getDocumentElement();
    NodeList nodeList = root.getChildNodes();
    char ch = 'a';
    for (int i = 0; i < nodeList.getLength(); i++) {
      Element node = (Element) nodeList.item(i);
      Assert.assertEquals("node name", "item", node.getNodeName());
      Assert.assertEquals("attribute value", String.valueOf(ch), node.getAttribute("name"));
      ch += 1;
    }
  }
Beispiel #29
0
  /**
   * Constructs an attribute element from an existing XML block.
   *
   * @param element representing a DOM tree element.
   * @exception SAMLException if there is an error in the sender or in the element definition.
   */
  public Attribute(Element element) throws SAMLException {
    // make sure that the input xml block is not null
    if (element == null) {
      SAMLUtilsCommon.debug.message("Attribute: Input is null.");
      throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("nullInput"));
    }
    // Make sure this is an Attribute.
    String tag = null;
    tag = element.getLocalName();
    if ((tag == null) || (!tag.equals("Attribute"))) {
      SAMLUtilsCommon.debug.message("Attribute: wrong input");
      throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("wrongInput"));
    }
    int i = 0;
    // handle attributes
    NamedNodeMap atts = element.getAttributes();
    int attrCount = atts.getLength();
    for (i = 0; i < attrCount; i++) {
      Node att = atts.item(i);
      if (att.getNodeType() == Node.ATTRIBUTE_NODE) {
        String attName = att.getLocalName();
        if (attName == null) {
          attName = att.getNodeName();
        }
        if (attName == null || attName.length() == 0) {
          if (SAMLUtilsCommon.debug.messageEnabled()) {
            SAMLUtilsCommon.debug.message("Attribute:" + "Attribute Name is either null or empty.");
          }
          continue;
          // throw new SAMLRequesterException(
          //  SAMLUtilsCommon.bundle.getString("nullInput"));
        }
        if (attName.equals("AttributeName")) {
          this._attributeName = ((Attr) att).getValue().trim();
        } else if (attName.equals("AttributeNamespace")) {
          this._attributeNameSpace = ((Attr) att).getValue().trim();
        }
      }
    }
    // AttributeName is required
    if (_attributeName == null || _attributeName.length() == 0) {
      if (SAMLUtilsCommon.debug.messageEnabled()) {
        SAMLUtilsCommon.debug.message("Attribute: " + "AttributeName is required attribute");
      }
      throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("missingAttribute"));
    }

    // AttributeNamespace is required
    if (_attributeNameSpace == null || _attributeNameSpace.length() == 0) {
      if (SAMLUtilsCommon.debug.messageEnabled()) {
        SAMLUtilsCommon.debug.message("Attribute: " + "AttributeNamespace is required attribute");
      }
      throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("missingAttribute"));
    }

    // handle the children of Attribute element
    NodeList nodes = element.getChildNodes();
    int nodeCount = nodes.getLength();
    if (nodeCount > 0) {
      for (i = 0; i < nodeCount; i++) {
        Node currentNode = nodes.item(i);
        if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
          String tagName = currentNode.getLocalName();
          String tagNS = currentNode.getNamespaceURI();
          if ((tagName == null) || tagName.length() == 0 || tagNS == null || tagNS.length() == 0) {
            if (SAMLUtilsCommon.debug.messageEnabled()) {
              SAMLUtilsCommon.debug.message(
                  "Attribute:"
                      + " The tag name or tag namespace of child"
                      + " element is either null or empty.");
            }
            throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("nullInput"));
          }
          if (tagName.equals("AttributeValue")
              && tagNS.equals(SAMLConstants.assertionSAMLNameSpaceURI)) {
            if (_attributeValue == null) {
              _attributeValue = new ArrayList();
            }
            if (!(_attributeValue.add((Element) currentNode))) {
              if (SAMLUtilsCommon.debug.messageEnabled()) {
                SAMLUtilsCommon.debug.message(
                    "Attribute: failed to " + "add to the attribute value list.");
              }
              throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("addListError"));
            }
          } else {
            if (SAMLUtilsCommon.debug.messageEnabled()) {
              SAMLUtilsCommon.debug.message("Attribute:" + "wrong element:" + tagName);
            }
            throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("wrongInput"));
          }
        } // end of if (currentNode.getNodeType() == Node.ELEMENT_NODE)
      } // end of for loop
    } // end of if (nodeCount > 0)

    if (_attributeValue == null || _attributeValue.isEmpty()) {
      if (SAMLUtilsCommon.debug.messageEnabled()) {
        SAMLUtilsCommon.debug.message(
            "Attribute: " + "should contain at least one AttributeValue.");
      }
      throw new SAMLRequesterException(SAMLUtilsCommon.bundle.getString("missingElement"));
    }
  }
  protected void init(Element root) {
    NodeList children = root.getChildNodes();

    for (int i = 0; i < children.getLength(); i++) {
      Node child = children.item(i);

      if (child.getNodeName().equals("meta")) {
        Element meta = (Element) child;
        String value = XMLUtil.getText(meta);
        this.metaAttributes.put(meta.getAttribute("name"), value);
      }
    }

    // handle registers - OPTIONAL
    Element r = XMLUtil.getChildElement(root, "registers");

    if (r != null) {
      List registers = XMLUtil.getChildElements(r, "register");

      for (int i = 0; i < registers.size(); i++) {
        Element register = (Element) registers.get(i);
        RegisterDescriptor registerDescriptor =
            DescriptorFactory.getFactory().createRegisterDescriptor(register);
        registerDescriptor.setParent(this);
        this.registers.add(registerDescriptor);
      }
    }

    // handle global-conditions - OPTIONAL
    Element globalConditionsElement = XMLUtil.getChildElement(root, "global-conditions");

    if (globalConditionsElement != null) {
      Element globalConditions = XMLUtil.getChildElement(globalConditionsElement, "conditions");

      ConditionsDescriptor conditionsDescriptor =
          DescriptorFactory.getFactory().createConditionsDescriptor(globalConditions);
      conditionsDescriptor.setParent(this);
      this.globalConditions = conditionsDescriptor;
    }

    // handle initial-steps - REQUIRED
    Element intialActionsElement = XMLUtil.getChildElement(root, "initial-actions");
    List initialActions = XMLUtil.getChildElements(intialActionsElement, "action");

    for (int i = 0; i < initialActions.size(); i++) {
      Element initialAction = (Element) initialActions.get(i);
      ActionDescriptor actionDescriptor =
          DescriptorFactory.getFactory().createActionDescriptor(initialAction);
      actionDescriptor.setParent(this);
      this.initialActions.add(actionDescriptor);
    }

    // handle global-actions - OPTIONAL
    Element globalActionsElement = XMLUtil.getChildElement(root, "global-actions");

    if (globalActionsElement != null) {
      List globalActions = XMLUtil.getChildElements(globalActionsElement, "action");

      for (int i = 0; i < globalActions.size(); i++) {
        Element globalAction = (Element) globalActions.get(i);
        ActionDescriptor actionDescriptor =
            DescriptorFactory.getFactory().createActionDescriptor(globalAction);
        actionDescriptor.setParent(this);
        this.globalActions.add(actionDescriptor);
      }
    }

    // handle common-actions - OPTIONAL
    //   - Store actions in HashMap for now. When parsing Steps, we'll resolve
    //      any common actions into local references.
    Element commonActionsElement = XMLUtil.getChildElement(root, "common-actions");

    if (commonActionsElement != null) {
      List commonActions = XMLUtil.getChildElements(commonActionsElement, "action");

      for (int i = 0; i < commonActions.size(); i++) {
        Element commonAction = (Element) commonActions.get(i);
        ActionDescriptor actionDescriptor =
            DescriptorFactory.getFactory().createActionDescriptor(commonAction);
        actionDescriptor.setParent(this);
        addCommonAction(actionDescriptor);
      }
    }

    // handle timer-functions - OPTIONAL
    Element timerFunctionsElement = XMLUtil.getChildElement(root, "trigger-functions");

    if (timerFunctionsElement != null) {
      List timerFunctions = XMLUtil.getChildElements(timerFunctionsElement, "trigger-function");

      for (int i = 0; i < timerFunctions.size(); i++) {
        Element timerFunction = (Element) timerFunctions.get(i);
        Integer id = new Integer(timerFunction.getAttribute("id"));
        FunctionDescriptor function =
            DescriptorFactory.getFactory()
                .createFunctionDescriptor(XMLUtil.getChildElement(timerFunction, "function"));
        function.setParent(this);
        this.timerFunctions.put(id, function);
      }
    }

    // handle steps - REQUIRED
    Element stepsElement = XMLUtil.getChildElement(root, "steps");
    List steps = XMLUtil.getChildElements(stepsElement, "step");

    for (int i = 0; i < steps.size(); i++) {
      Element step = (Element) steps.get(i);
      StepDescriptor stepDescriptor =
          DescriptorFactory.getFactory().createStepDescriptor(step, this);
      this.steps.add(stepDescriptor);
    }

    // handle splits - OPTIONAL
    Element splitsElement = XMLUtil.getChildElement(root, "splits");

    if (splitsElement != null) {
      List split = XMLUtil.getChildElements(splitsElement, "split");

      for (int i = 0; i < split.size(); i++) {
        Element s = (Element) split.get(i);
        SplitDescriptor splitDescriptor = DescriptorFactory.getFactory().createSplitDescriptor(s);
        splitDescriptor.setParent(this);
        this.splits.add(splitDescriptor);
      }
    }

    // handle joins - OPTIONAL:
    Element joinsElement = XMLUtil.getChildElement(root, "joins");

    if (joinsElement != null) {
      List join = XMLUtil.getChildElements(joinsElement, "join");

      for (int i = 0; i < join.size(); i++) {
        Element s = (Element) join.get(i);
        JoinDescriptor joinDescriptor = DescriptorFactory.getFactory().createJoinDescriptor(s);
        joinDescriptor.setParent(this);
        this.joins.add(joinDescriptor);
      }
    }
  }