domsourcexmlstreamreaderimpl.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 716 行 · 第 1/2 页

      if (colon < 0) {
        if (element.getNamespaceURI() == null || 
            "".equals(element.getNamespaceURI()))
          return new QName(element.getLocalName());
        else 
          return new QName(element.getNamespaceURI(), element.getLocalName());
      }

      String prefix = name.substring(0, colon);

      return new QName(element.getNamespaceURI(), 
                       element.getLocalName(), 
                       prefix);
    }
    else {
      throw new IllegalStateException(L.l("Current event not a start or end element"));
    }
  }

  public NamespaceContext getNamespaceContext()
  {
    return _namespaceTracker;
  }

  public int getNamespaceCount()
  {
    return _namespaceTracker.getNumDecls();
  }

  public String getNamespacePrefix(int index)
  {
    String prefix = _namespaceTracker.getPrefix(index);

    // The API specifies that this function return a different value for
    // the default namespace, null, than any other function, which all return
    // the constant defined in XMLConstants.
    if (DEFAULT_NS_PREFIX.equals(prefix))
      return null;
    else
      return prefix;
  }

  public String getNamespaceURI(int index)
  {
    return _namespaceTracker.getUri(index);
  }

  public String getNamespaceURI(String prefix)
  {
    return _namespaceTracker.getUri(prefix);
  }

  public String getPIData()
  {
    if (_current.getNodeType() != PROCESSING_INSTRUCTION_NODE)
      return null;

    ProcessingInstruction pi = (ProcessingInstruction) _current;

    return pi.getData();
  }

  public String getPITarget()
  {
    if (_current.getNodeType() != PROCESSING_INSTRUCTION_NODE)
      return null;

    ProcessingInstruction pi = (ProcessingInstruction) _current;

    return pi.getTarget();
  }

  public String getPrefix()
  {
    if (isStartElement()) {
      Element element = (Element) _current;

      String name = element.getNodeName();

      int colon = name.indexOf(':');

      if (colon < 0)
        return DEFAULT_NS_PREFIX;

      return name.substring(0, colon);
    }
    else {
      throw new IllegalStateException(L.l("Current event not a start or end element"));
    }
  }

  public Object getProperty(String name) throws IllegalArgumentException
  {
    if ("javax.xml.stream.notations".equals(name)) {
      throw new UnsupportedOperationException(getClass().getName());
    }
    else if ("javax.xml.stream.entities".equals(name)) {
      throw new UnsupportedOperationException(getClass().getName());
    }
    else {
      throw
        new IllegalArgumentException("property \""+name+"+\" not supported");
    }
  }

  /**
   * Returns the current text string.
   */
  public String getText()
  {
    if (_current instanceof CharacterData) {
      CharacterData data = (CharacterData) _current;

      return data.getData();
    }

    throw new IllegalStateException("Not a text node");
  }

  /**
   * Returns a character buffer for the current text.
   */
  public char[] getTextCharacters()
  {
    return getText().toCharArray();
  }

  /**
   * Reads the current text into a buffer.
   */
  public int getTextCharacters(int sourceStart, char[] target,
                               int targetStart, int length)
    throws XMLStreamException
  {
    char[] source = getTextCharacters();

    int ret = Math.min(source.length - sourceStart, length);

    System.arraycopy(source, sourceStart, target, targetStart, ret);

    return ret;
  }

  /**
   * Returns the length of the current text.
   */
  public int getTextLength()
  {
    return getText().length();
  }

  /**
   * Returns the offset of the current text.
   */
  public int getTextStart()
  {
    return 0;
  }

  public String getVersion()
  {
    return _version;
  }

  public boolean hasName()
  {
    return _current.getNodeType() == ELEMENT_NODE;
  }

  public boolean hasText()
  {
    switch (_current.getNodeType()) {
      case TEXT_NODE:
      case DOCUMENT_TYPE_NODE:
      case ENTITY_REFERENCE_NODE:
      case COMMENT_NODE:
        return true;
      default:
        return false;
    }
  }

  public boolean isCharacters()
  {
    return _current.getNodeType() == TEXT_NODE;
  }

  public boolean isEndElement()
  {
    return _ending;
  }

  public boolean isStandalone()
  {
    return _standalone;
  }

  public boolean isStartElement()
  {
    return _current != null &&
           _current.getNodeType() == ELEMENT_NODE && 
           ! _ending;
  }

  public boolean isWhiteSpace()
  {
    if (! isCharacters())
      return false;

    String text = getText();

    for (int i = 0; i < text.length(); i++) {
      if (! Character.isWhitespace(text.charAt(i)))
        return false;
    }

    return true;
  }

  /**
   * Skips until the next START_ELEMENT or END_ELEMENT
   */
  public int nextTag() throws XMLStreamException
  {
    while (true) {
      int tag = next();

      if (tag < 0
          || tag == START_ELEMENT
          || tag == END_ELEMENT) {
        return tag;
      }
    }
  }

  public void require(int type, String namespaceURI, String localName)
    throws XMLStreamException
  {
    if (type != getEventType())
      throw new XMLStreamException("expected " + constantToString(type) + ", "+
                                   "found " + constantToString(getEventType()) +
                                   " at " + getLocation());

    if (localName != null && ! localName.equals(getLocalName()))
      throw new XMLStreamException("expected <"+localName+">, found " +
                                   "<"+getLocalName()+"> at " + getLocation());

    if (namespaceURI != null && ! namespaceURI.equals(getNamespaceURI()))
      throw new XMLStreamException("expected xmlns="+namespaceURI+
                                   ", found xmlns="+getNamespaceURI() +
                                   " at " + getLocation());
  }

  public boolean standaloneSet()
  {
    return isStandalone();
  }

  public boolean hasNext() throws XMLStreamException
  {
    return (_current != null && getEventType() != END_DOCUMENT);
  }

  public int next() throws XMLStreamException
  {
    if (_current == null)
      throw new NoSuchElementException();

    if (_first) {
      _first = false;
      return getEventType();
    }

    if (_ending) {
      if (_current.getNodeType() == ELEMENT_NODE)
        _namespaceTracker.pop();

      if (_current.getNextSibling() != null) {
        _current = _current.getNextSibling();
        _ending = false;
      }
      else 
        _current = _current.getParentNode();
    }
    else if (_current.getFirstChild() != null) {
      _current = _current.getFirstChild();
    }
    else if (isStartElement()) {
      _ending = true;
    }
    else if (_current.getNextSibling() != null) {
      _current = _current.getNextSibling();
    }
    else {
      _current = _current.getParentNode();
      _ending = true;
    }

    declareNamespaces();

    return getEventType();
  }

  public void close() throws XMLStreamException
  {
  }

  private class UnknownLocation implements Location {
    public int getCharacterOffset()
    {
      return -1;
    }

    public int getColumnNumber()
    {
      return -1;
    }

    public int getLineNumber()
    {
      return -1;
    }

    public String getPublicId()
    {
      return null;
    }

    public String getSystemId()
    {
      return null;
    }
  }

  private static String constantToString(int constant) {
    switch(constant) {
      case ATTRIBUTE: return "ATTRIBUTE";
      case CDATA: return "CDATA";
      case CHARACTERS: return "CHARACTERS";
      case COMMENT: return "COMMENT";
      case DTD: return "DTD";
      case END_DOCUMENT: return "END_DOCUMENT";
      case END_ELEMENT: return "END_ELEMENT";
      case ENTITY_DECLARATION: return "ENTITY_DECLARATION";
      case ENTITY_REFERENCE: return "ENTITY_REFERENCE";
      case NAMESPACE: return "NAMESPACE";
      case NOTATION_DECLARATION: return "NOTATION_DECLARATION";
      case PROCESSING_INSTRUCTION: return "PROCESSING_INSTRUCTION";
      case SPACE: return "SPACE";
      case START_DOCUMENT: return "START_DOCUMENT";
      case START_ELEMENT: return "START_ELEMENT";
      default:
        throw new RuntimeException("constantToString("+constant+") unknown");
    }
  }
}