/**
  * Get n'th attribute (DOM NamedNodeMap method). In this implementation we number the attributes
  * as follows: 0 - the xmlns:xml namespace declaration 1-n further namespace declarations n+1...
  * "real" attribute declarations
  */
 public Node item(int index) {
   if (index < 0) {
     return null;
   }
   if (index == 0) {
     NamespaceIterator.NamespaceNodeImpl nn =
         new NamespaceIterator.NamespaceNodeImpl(parent, NamespaceConstant.XML_NAMESPACE_CODE, 0);
     return NodeOverNodeInfo.wrap(nn);
   }
   int nscount = getNumberOfNamespaces();
   if (index < nscount) {
     int[] buffer = new int[8];
     int[] nsList = parent.getDeclaredNamespaces(buffer);
     int nscode = nsList[index - 1];
     NamespaceIterator.NamespaceNodeImpl nn =
         new NamespaceIterator.NamespaceNodeImpl(parent, nscode, index);
     return NodeOverNodeInfo.wrap(nn);
   }
   int pos = 0;
   int attNr = (index - nscount);
   AxisIterator atts = parent.iterateAxis(Axis.ATTRIBUTE);
   while (true) {
     NodeInfo att = (NodeInfo) atts.next();
     if (att == null) {
       return null;
     }
     if (pos == attNr) {
       return NodeOverNodeInfo.wrap(att);
     }
     pos++;
   }
 }
Esempio n. 2
0
 @Override
 public String convert(NodeInfo source) {
   switch (source.getNodeKind()) {
     case Node.DOCUMENT_NODE:
       return "";
     case Node.TEXT_NODE:
     case Node.CDATA_SECTION_NODE:
       return "text()";
     case Node.COMMENT_NODE:
       return "comment()";
     case Node.PROCESSING_INSTRUCTION_NODE:
       return "processing-instruction('" + source.getDisplayName() + "')";
     case Node.ELEMENT_NODE:
       String prefix = nsContext.getPrefix(source.getURI());
       String name = source.getLocalPart();
       return StringUtil.isEmpty(prefix) ? name : prefix + ':' + name;
     case Node.ATTRIBUTE_NODE:
       if (Namespaces.URI_XMLNS.equals(source.getURI()))
         return "namespace::" + source.getLocalPart();
       prefix = nsContext.getPrefix(source.getURI());
       name = source.getLocalPart();
       return '@' + (StringUtil.isEmpty(prefix) ? name : prefix + ':' + name);
     case NodeType.NAMESPACE:
       return "namespace::" + source.getLocalPart();
     default:
       return null;
   }
 }
Esempio n. 3
0
 /**
  * Set all the declared namespaces to be the namespaces that are in-scope for a given node. In
  * addition, the standard namespaces (xml, xslt, saxon) are declared.
  *
  * @param node The node whose in-scope namespaces are to be used as the context namespaces. Note
  *     that this will have no effect unless this node is an element.
  */
 public void setNamespaces(NodeInfo node) {
   namespaces.clear();
   AxisIterator iter = node.iterateAxis(Axis.NAMESPACE);
   while (true) {
     NodeInfo ns = (NodeInfo) iter.next();
     if (ns == null) {
       return;
     }
     declareNamespace(ns.getLocalPart(), ns.getStringValue());
   }
 }
Esempio n. 4
0
 /**
  * Provide information about the node being copied. This method is called immediately before the
  * startElement call for the element node in question.
  *
  * @param element the node being copied, which must be an element node
  */
 public int notifyElementNode(NodeInfo element) {
   systemId = (wholeDocument ? element.getSystemId() : element.getBaseURI());
   // The logic behind this is that if we are copying the whole document, we will be copying all
   // the relevant xml:base attributes; so retaining the systemId values is sufficient to enable
   // the base URIs of the nodes to be preserved. But if we only copy an element (for example
   // an xsl:import-schema element - see test schema091 - then its base URI might be affected
   // by xml:base attributes that aren't being copied. Ideally we would have two separate
   // properties,
   // but XDM doesn't work that way.
   lineNumber = element.getLineNumber();
   return 0;
 }
 /** Get number of attributes and namespaces (DOM NamedNodeMap method). */
 public int getLength() {
   int length = 0;
   AxisIterator atts = parent.iterateAxis(Axis.ATTRIBUTE);
   while (atts.next() != null) {
     length++;
   }
   return getNumberOfNamespaces() + length;
 }
Esempio n. 6
0
 /**
  * Create a StandaloneContext using a specific Node. This node is used to initialize the NamePool
  * and also to establish the initial set of in-scope namespaces
  */
 public StandaloneContext(NodeInfo node) {
   DocumentInfo doc = node.getDocumentRoot();
   if (doc == null) {
     throw new IllegalArgumentException(
         "The node used to establish a standalone context must be in a tree whose root is a document node");
   }
   namePool = doc.getNamePool();
   setNamespaces(node);
 }
Esempio n. 7
0
 @Override
 public String convert(NodeInfo source) {
   switch (source.getNodeKind()) {
     case NodeType.ATTRIBUTE:
     case NodeType.NAMESPACE:
       return delegate.convert(source);
   }
   return super.convert(source);
 }
Esempio n. 8
0
  public static void assertXPathEquals(
      String xpathString, Document doc, boolean ignoreOrder, Object... expectedValues) {
    try {
      XPathEvaluator xpathEvaluator = new XPathEvaluator();
      XPathExpression expr = xpathEvaluator.createExpression(xpathString);

      final JDOMSource docAsDomSource = new JDOMSource(doc);

      List nodes = expr.evaluate(docAsDomSource);

      if (nodes.size() != expectedValues.length) {
        org.junit.Assert.fail(
            "expected " + expectedValues.length + " values at xpath: " + xpathString);
      }

      String[] actualValues = new String[nodes.size()];
      for (int i = 0; i < expectedValues.length; i++) {
        Object node = nodes.get(i);
        if (node instanceof NodeInfo) {
          NodeInfo nodeInfo = (NodeInfo) node;
          actualValues[i] = nodeInfo.getStringValue();
        } else {
          actualValues[i] = String.valueOf(node);
        }
      }

      String[] expectedValuesAsString = new String[expectedValues.length];
      for (int i = 0; i < expectedValues.length; i++) {
        expectedValuesAsString[i] = String.valueOf(expectedValues[i]);
      }

      if (ignoreOrder) {
        Arrays.sort(actualValues);
        Arrays.sort(expectedValuesAsString);
      }

      org.junit.Assert.assertArrayEquals(expectedValuesAsString, actualValues);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
 /** Get named attribute (DOM NamedNodeMap method) */
 public Node getNamedItemNS(String uri, String localName) {
   if (uri == null) {
     uri = "";
   }
   if (NamespaceConstant.XMLNS.equals(uri)) {
     return getNamedItem("xmlns:" + localName);
   }
   if (uri.equals("") && localName.equals("xmlns")) {
     return getNamedItem("xmlns");
   }
   AxisIterator atts = parent.iterateAxis(Axis.ATTRIBUTE);
   while (true) {
     NodeInfo att = (NodeInfo) atts.next();
     if (att == null) {
       return null;
     }
     if (uri.equals(att.getURI()) && localName.equals(att.getLocalPart())) {
       return NodeOverNodeInfo.wrap(att);
     }
   }
 }
Esempio n. 10
0
 @Override
 @SuppressWarnings({"unchecked"})
 public List<?> translate(Object result, NamespaceContext nsContext) {
   List nodeList = (List) result;
   int i = 0;
   for (Object item : nodeList) {
     if (item instanceof List) nodeList.set(i, translate(item, nsContext));
     else {
       NodeInfo node = (NodeInfo) item;
       int type = node.getNodeKind();
       String value = "";
       if (type != NodeType.DOCUMENT && type != NodeType.ELEMENT) value = node.getStringValue();
       String localName = node.getLocalPart();
       String namespaceURI = node.getURI();
       String qualifiedName = node.getDisplayName();
       String location = SaxonNavigator.INSTANCE.getXPath(node, nsContext);
       NodeItem nodeItem =
           new NodeItem(type, location, value, localName, namespaceURI, qualifiedName);
       nodeItem.xml = node;
       nodeList.set(i, nodeItem);
     }
     i++;
   }
   return nodeList;
 }
 private String serialize(final Object o, final String method, final boolean includeProlog)
     throws XPathException {
   if (o instanceof NodeInfo) {
     final NodeInfo nodeInfo = ((NodeInfo) o);
     final Configuration config = nodeInfo.getConfiguration();
     final StringWriter sw = new StringWriter();
     final Properties props = new Properties();
     props.setProperty("method", method);
     props.setProperty("indent", "no");
     if (!includeProlog) {
       props.setProperty("omit-xml-declaration", "yes");
     } else {
       props.setProperty("omit-xml-declaration", "no");
     }
     final Receiver serializer =
         config
             .getSerializerFactory()
             .getReceiver(new StreamResult(sw), config.makePipelineConfiguration(), props);
     nodeInfo.copy(serializer, NodeInfo.ALL_NAMESPACES, true, 0);
     return sw.toString();
   }
   return null;
 }
 /** Get the number of declared namespaces */
 private int getNumberOfNamespaces() {
   if (numberOfNamespaces == -1) {
     int[] buffer = new int[8];
     int[] nsList = parent.getDeclaredNamespaces(buffer);
     int count = nsList.length;
     for (int i = 0; i < count; i++) {
       if (nsList[i] == -1) {
         count = i;
         break;
       }
     }
     numberOfNamespaces = count + 1; // +1 for the XML namespace
   }
   return numberOfNamespaces;
 }
Esempio n. 13
0
  @Override
  public void write(NodeInfo node, String uri) {
    UpdateHandler updateHandler = core.getUpdateHandler();

    // Create a version of the document for saving to the transaction log,
    // or for cloud update via HTTP
    SolrInputDocument solrDoc = new SolrInputDocument();
    solrDoc.addField(uriFieldName, uri);
    if (isCloud()) {
      // TODO: write as binary, but we need to enable the binary update request writer for this
      // TinyBinary tinybin = new TinyBinary(((TinyNodeImpl)node).getTree());
      // solrDoc.addField(xmlFieldName, tinybin.getByteBuffer().array());
      Serializer serializer = xqueryComponent.solrIndexConfig.checkoutSerializer();
      try {
        String xmlString = serializer.serializeNodeToString(new XdmNode(node));
        solrDoc.addField(xmlFieldName, xmlString);
      } catch (SaxonApiException e) {
        throw new LuxException(e);
      } finally {
        xqueryComponent.solrIndexConfig.returnSerializer(serializer);
      }
      // TODO -- if we can determine this doc only gets added locally??
      // solrDoc.addField(xmlFieldName, node);
    } else if (updateHandler.getUpdateLog() != null) {
      if (node instanceof TinyNodeImpl) {
        TinyBinary tinybin = new TinyBinary(((TinyNodeImpl) node).getTree());
        solrDoc.addField(xmlFieldName, tinybin.getByteBuffer());
      } else {
        String xml = node.toString();
        solrDoc.addField(xmlFieldName, xml);
      }
    }
    if (isCloud()) {
      writeToCloud(solrDoc, uri);
    } else {
      writeLocal(solrDoc, node, uri);
    }
  }
 /** Get named attribute (DOM NamedNodeMap method) */
 public Node getNamedItem(String name) {
   if (name.equals("xmlns")) {
     int[] nsarray = parent.getDeclaredNamespaces(null);
     for (int i = 0; i < nsarray.length; i++) {
       if (nsarray[i] == -1) {
         return null;
       } else if (((nsarray[i] >> 16) & 0xffff) == 0) {
         NamespaceIterator.NamespaceNodeImpl nn =
             new NamespaceIterator.NamespaceNodeImpl(parent, nsarray[i], i + 1);
         return NodeOverNodeInfo.wrap(nn);
       }
     }
     return null;
   } else if (name.startsWith("xmlns:")) {
     String prefix = name.substring(6);
     if (prefix.equals("xml")) {
       NamespaceIterator.NamespaceNodeImpl nn =
           new NamespaceIterator.NamespaceNodeImpl(parent, NamespaceConstant.XML_CODE, 0);
       return NodeOverNodeInfo.wrap(nn);
     }
     int[] buffer = new int[8];
     int[] nsarray = parent.getDeclaredNamespaces(buffer);
     for (int i = 0; i < nsarray.length; i++) {
       if (nsarray[i] == -1) {
         return null;
       } else if (prefix.equals(parent.getNamePool().getPrefixFromNamespaceCode(nsarray[i]))) {
         NamespaceIterator.NamespaceNodeImpl nn =
             new NamespaceIterator.NamespaceNodeImpl(parent, nsarray[i], i + 1);
         return NodeOverNodeInfo.wrap(nn);
       }
     }
     return null;
   } else {
     AxisIterator atts = parent.iterateAxis(Axis.ATTRIBUTE);
     while (true) {
       NodeInfo att = (NodeInfo) atts.next();
       if (att == null) {
         return null;
       }
       if (name.equals(att.getDisplayName())) {
         return NodeOverNodeInfo.wrap(att);
       }
     }
   }
 }
Esempio n. 15
0
 public static boolean isNamespaceDeclaration(NodeInfo attr) {
   return Namespaces.URI_XMLNS.equals(attr.getURI())
       || attr instanceof NamespaceIterator.NamespaceNodeImpl;
 }
  /** Enumerate the results of the expression */
  public SequenceIterator iterate(XPathContext context) throws XPathException {

    Controller controller = context.getController();

    Item arg2;
    try {
      arg2 = argument[2].evaluateItem(context);
    } catch (XPathException e) {
      if ("XPDY0002".equals(e.getErrorCodeLocalPart())) {
        dynamicError(
            "Cannot call the key() function when there is no context item", "XTDE1270", context);
        return null;
      } else if ("XPDY0050".equals(e.getErrorCodeLocalPart())) {
        dynamicError(
            "In the key() function,"
                + " the node supplied in the third argument (or the context node if absent)"
                + " must be in a tree whose root is a document node",
            "XTDE1270",
            context);
        return null;
      } else if ("XPTY0020".equals(e.getErrorCodeLocalPart())) {
        dynamicError(
            "Cannot call the key() function when the context item is an atomic value",
            "XTDE1270",
            context);
        return null;
      }
      throw e;
    }

    NodeInfo origin = (NodeInfo) arg2;
    NodeInfo root = origin.getRoot();
    if (root.getNodeKind() != Type.DOCUMENT) {
      dynamicError(
          "In the key() function,"
              + " the node supplied in the third argument (or the context node if absent)"
              + " must be in a tree whose root is a document node",
          "XTDE1270",
          context);
      return null;
    }
    DocumentInfo doc = (DocumentInfo) root;

    int fprint = keyFingerprint;
    if (fprint == -1) {
      String givenkeyname = argument[0].evaluateItem(context).getStringValue();
      try {
        fprint =
            controller
                    .getNamePool()
                    .allocateLexicalQName(
                        givenkeyname,
                        false,
                        nsContext,
                        controller.getConfiguration().getNameChecker())
                & NamePool.FP_MASK;
      } catch (XPathException err) {
        dynamicError("Invalid key name: " + err.getMessage(), "XTDE1260", context);
      }
      if (fprint == -1) {
        dynamicError("Key '" + givenkeyname + "' has not been defined", "XTDE1260", context);
        return null;
      }
    }

    //        if (internal) {
    //            System.err.println("Using key " + fprint + " on doc " + doc);
    //        }

    // If the second argument is a singleton, we evaluate the function
    // directly; otherwise we recurse to evaluate it once for each Item
    // in the sequence.

    Expression expression = argument[1];
    SequenceIterator allResults;
    if (Cardinality.allowsMany(expression.getCardinality())) {
      final XPathContext keyContext = context;
      final DocumentInfo document = doc;
      final KeyManager keyManager = controller.getKeyManager();
      MappingFunction map =
          new MappingFunction() {
            // Map a value to the sequence of nodes having that value as a key value
            public Object map(Item item) throws XPathException {
              return keyManager.selectByKey(
                  keyFingerprint, document, (AtomicValue) item, keyContext);
            }
          };

      SequenceIterator keys = argument[1].iterate(context);
      SequenceIterator allValues = new MappingIterator(keys, map);
      allResults = new DocumentOrderIterator(allValues, LocalOrderComparer.getInstance());
    } else {
      try {
        AtomicValue keyValue = (AtomicValue) argument[1].evaluateItem(context);
        if (keyValue == null) {
          return EmptyIterator.getInstance();
        }
        KeyManager keyManager = controller.getKeyManager();
        allResults = keyManager.selectByKey(fprint, doc, keyValue, context);
      } catch (XPathException e) {
        if (e.getLocator() == null) {
          e.setLocator(this);
        }
        throw e;
      }
    }
    if (origin == doc) {
      return allResults;
    }
    SubtreeFilter filter = new SubtreeFilter();
    filter.origin = origin;
    return new ItemMappingIterator(allResults, filter);
  }
Esempio n. 17
0
 /**
  * Test whether this node test is satisfied by a given node. This alternative method is used in
  * the case of nodes where calculating the fingerprint is expensive, for example DOM or JDOM
  * nodes.
  *
  * @param node the node to be matched
  */
 public boolean matches(NodeInfo node) {
   return node.getNodeKind() == kind;
 }
Esempio n. 18
0
 /*@NotNull*/ public Value atomize(/*@NotNull*/ NodeInfo node) {
   return new UntypedAtomicValue(node.getStringValueCS());
 }
Esempio n. 19
0
 NodeInfoSequence(NodeInfo nodeInfo, byte axis) {
   this.nodeInfo = nodeInfo;
   this.axis = axis;
   iterator = nodeInfo.iterateAxis(axis);
 }
Esempio n. 20
0
 public String getXPath(NodeInfo node, NamespaceContext nsContext) {
   if (node.getNodeKind() == NodeType.DOCUMENT) return "/";
   else return getPath(node, new XPathConvertor(nsContext), "/");
 }
Esempio n. 21
0
  public SequenceIterator iterate(XPathContext context) throws XPathException {
    Controller controller = context.getController();
    ObjectValue ov = (ObjectValue) controller.getParameter("{" + Test.TE_NS + "}core");
    TECore core = (TECore) ov.getObject();

    Expression[] argExpressions = getArguments();
    String xml = "<params>\n";
    List<QName> params = fe.getParams();
    for (int i = 0; i < params.size(); i++) {
      QName param = params.get(i);
      xml += "<param";
      xml += " local-name=\"" + param.getLocalPart() + "\"";
      xml += " namespace-uri=\"" + param.getNamespaceURI() + "\"";
      xml += " prefix=\"" + param.getPrefix() + "\"";
      ValueRepresentation vr = ExpressionTool.eagerEvaluate(argExpressions[i], context);
      // ValueRepresentation vr =
      // ExpressionTool.lazyEvaluate(argExpressions[i], context, 1);
      Value v = Value.asValue(vr);
      try {
        Node n = (Node) v.convertToJava(Node.class, context);
        int type = n.getNodeType();
        if (type == Node.ATTRIBUTE_NODE) {
          xml += ">\n";
          Attr attr = (Attr) n;
          xml +=
              "<value " + attr.getNodeName() + "=\"" + attr.getValue().replace("&", "&amp;") + "\"";
          if (attr.getPrefix() != null) {
            xml += " xmlns:" + attr.getPrefix() + "=\"" + attr.getNamespaceURI() + "\"";
          }
          xml += "/>\n";
          // } else if (type == Node.ELEMENT_NODE || type ==
          // Node.DOCUMENT_NODE) {
          // xml += ">\n";
          // xml += "<value>";
          // xml += DomUtils.serializeNode(n);
          // xml += "</value>\n";
        } else if (type == Node.ELEMENT_NODE) {
          xml += " type=\"node()\">\n";
          xml += "<value>";
          xml += DomUtils.serializeNode(n);
          xml += "</value>\n";
        } else if (type == Node.DOCUMENT_NODE) {
          xml += " type=\"document-node()\">\n";
          xml += "<value>";
          xml += DomUtils.serializeNode(n);
          xml += "</value>\n";
        } else {
          ItemType it = v.getItemType(context.getConfiguration().getTypeHierarchy());
          xml += " type=\"" + getTypeName(it) + "\">\n";
          xml += "<value>" + n.getNodeValue() + "</value>\n";
        }
      } catch (Exception e) {
        ItemType it = v.getItemType(context.getConfiguration().getTypeHierarchy());
        xml += " type=\"" + getTypeName(it) + "\">\n";
        xml += "<value>" + v.getStringValue() + "</value>\n";
      }
      xml += "</param>\n";
    }
    xml += "</params>";
    // System.out.println(xml);
    Source src = new StreamSource(new CharArrayReader(xml.toCharArray()));
    // XdmValue result = null;
    NodeInfo result = null;
    try {
      // result = core.executeTemplate(fe, Globals.builder.build(src),
      // context);
      NodeInfo paramsNode = core.getEngine().getBuilder().build(src).getUnderlyingNode();
      result = core.executeXSLFunction(context, fe, paramsNode);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    if (result == null) {
      return EmptyIterator.getInstance();
    } else {
      // Value v = Value.asValue(result);
      // return v.iterate();
      return result.iterateAxis(Axis.CHILD);
    }
  }
Esempio n. 22
0
 /*@NotNull*/ public SequenceIterator getTypedValue(/*@NotNull*/ NodeInfo node) {
   return SingletonIterator.makeIterator(new UntypedAtomicValue(node.getStringValueCS()));
 }
Esempio n. 23
0
  private boolean shallowEquals(NodeInfo n1, Node n2) {
    if (n1 == n2) return true;
    if (n1 == null || n2 == null) return false;

    int type1 = n1.getNodeKind();
    if (type1 == Node.CDATA_SECTION_NODE) type1 = Node.TEXT_NODE;
    else if (type1 == NodeType.NAMESPACE) type1 = Node.ATTRIBUTE_NODE;

    int type2 = n2.getNodeType();
    if (type2 == Node.CDATA_SECTION_NODE) type2 = Node.TEXT_NODE;

    if (type1 != type2) return false;

    switch (type1) {
      case Node.PROCESSING_INSTRUCTION_NODE:
        ProcessingInstruction pi2 = (ProcessingInstruction) n2;
        String target1 = n1.getDisplayName();
        String target2 = pi2.getTarget();
        if (!target1.equals(target2)) return false;
        String data1 = n1.getStringValue();
        String data2 = pi2.getData();
        if (!data1.equals(data2)) return false;
        break;
      case Node.COMMENT_NODE:
        Comment comment2 = (Comment) n2;
        data1 = n1.getStringValue();
        data2 = comment2.getData();
        if (!data1.equals(data2)) return false;
        break;
      case Node.ELEMENT_NODE:
        Element element2 = (Element) n2;
        String namespaceURI1 = n1.getURI();
        if (namespaceURI1 == null) namespaceURI1 = "";
        String namespaceURI2 = element2.getNamespaceURI();
        if (namespaceURI2 == null) namespaceURI2 = "";
        if (!namespaceURI1.equals(namespaceURI2)) return false;
        String localName1 = n1.getLocalPart();
        String localName2 = element2.getLocalName();
        if (!localName1.equals(localName2)) return false;

        NodeInfoSequence attrs1 = new NodeInfoSequence(n1, Axis.ATTRIBUTE);
        NamedNodeMap attrs2 = element2.getAttributes();
        BitSet bitSet = new BitSet();
        NodeInfo attr1;
        while ((attr1 = attrs1.findNext()) != null) {
          if (isNamespaceDeclaration(attr1)) continue;
          namespaceURI1 = attr1.getURI();
          if (namespaceURI1 == null) namespaceURI1 = "";
          localName1 = attr1.getLocalPart();
          String value1 = attr1.getStringValue();

          int found = -1;
          for (int i = 0; i < attrs2.getLength(); i++) {
            Attr attr2 = (Attr) attrs2.item(i);
            namespaceURI2 = attr2.getNamespaceURI();
            if (namespaceURI2 == null) namespaceURI2 = "";
            localName2 = attr2.getLocalName();
            if (namespaceURI1.equals(namespaceURI2) && localName1.equals(localName2)) {
              String value2 = attr2.getNodeValue();
              if (!value1.equals(value2)) return false;
              found = i;
              break;
            }
          }
          if (found == -1) return false;
          else bitSet.set(found);
        }
        for (int i = 0; i < attrs2.getLength(); i++) {
          if (!bitSet.get(i)) {
            Attr attr2 = (Attr) attrs2.item(i);
            if (!DOMUtil.isNamespaceDeclaration(attr2)) return false;
          }
        }

        break;
      case Node.ATTRIBUTE_NODE:
        Attr attr2 = (Attr) n2;
        namespaceURI1 = isNamespaceDeclaration(n1) ? Namespaces.URI_XMLNS : n1.getURI();
        if (namespaceURI1 == null) namespaceURI1 = "";
        namespaceURI2 = attr2.getNamespaceURI();
        if (namespaceURI2 == null) namespaceURI2 = "";
        if (!namespaceURI1.equals(namespaceURI2)) return false;
        localName1 = n1.getLocalPart();
        localName2 = attr2.getLocalName();
        if (!localName1.equals(localName2)) return false;
        String value1 = n1.getStringValue();
        String value2 = attr2.getNodeValue();
        if (!value1.equals(value2)) return false;
        break;
      case Node.TEXT_NODE:
        value1 = n1.getStringValue();
        value2 = n2.getNodeValue();
        if (!value1.equals(value2)) return false;
    }

    return true;
  }
Esempio n. 24
0
  public Expression compile(Executable exec) throws XPathException {
    NamespaceResolver nsContext = null;

    int annotation = getTypeAnnotation(schemaType);

    // deal specially with the case where the attribute name is known statically

    if (attributeName instanceof StringLiteral) {
      String qName = Whitespace.trim(((StringLiteral) attributeName).getStringValue());
      String[] parts;
      try {
        parts = getConfiguration().getNameChecker().getQNameParts(qName);
      } catch (QNameException e) {
        // This can't happen, because of previous checks
        return null;
      }

      if (namespace == null) {
        String nsuri = "";
        if (!parts[0].equals("")) {
          nsuri = getURIForPrefix(parts[0], false);
          if (nsuri == null) {
            undeclaredNamespaceError(parts[0], "XTSE0280");
            return null;
          }
        }
        int nameCode = getNamePool().allocate(parts[0], nsuri, parts[1]);
        FixedAttribute inst =
            new FixedAttribute(nameCode, validationAction, schemaType, annotation);
        inst.setContainer(this); // temporarily
        compileContent(exec, inst, separator);
        return inst;
      } else if (namespace instanceof StringLiteral) {
        String nsuri = ((StringLiteral) namespace).getStringValue();
        if (nsuri.equals("")) {
          parts[0] = "";
        } else if (parts[0].equals("")) {
          // Need to choose an arbitrary prefix
          // First see if the requested namespace is declared in the stylesheet
          AxisIterator iter = iterateAxis(Axis.NAMESPACE);
          while (true) {
            NodeInfo ns = (NodeInfo) iter.next();
            if (ns == null) {
              break;
            }
            if (ns.getStringValue().equals(nsuri)) {
              parts[0] = ns.getLocalPart();
              break;
            }
          }
          // Otherwise see the URI is known to the namepool
          if (parts[0].equals("")) {
            String p =
                getNamePool().suggestPrefixForURI(((StringLiteral) namespace).getStringValue());
            if (p != null) {
              parts[0] = p;
            }
          }
          // Otherwise choose something arbitrary. This will get changed
          // if it clashes with another attribute
          if (parts[0].equals("")) {
            parts[0] = "ns0";
          }
        }
        int nameCode = getNamePool().allocate(parts[0], nsuri, parts[1]);
        FixedAttribute inst =
            new FixedAttribute(nameCode, validationAction, schemaType, annotation);
        compileContent(exec, inst, separator);
        return inst;
      }
    } else {
      // if the namespace URI must be deduced at run-time from the attribute name
      // prefix, we need to save the namespace context of the instruction

      if (namespace == null) {
        nsContext = makeNamespaceContext();
      }
    }

    ComputedAttribute inst =
        new ComputedAttribute(
            attributeName, namespace, nsContext, validationAction, schemaType, annotation, false);
    compileContent(exec, inst, separator);
    return inst;
  }
Esempio n. 25
0
 @Override
 public NodeInfo parent(NodeInfo node) {
   return node.getParent();
 }