Пример #1
0
  Object addXMLObjects(Context cx, XMLObject obj1, XMLObject obj2) {
    XMLList listToAdd = newXMLList();

    if (obj1 instanceof XMLList) {
      XMLList list1 = (XMLList) obj1;
      if (list1.length() == 1) {
        listToAdd.addToList(list1.item(0));
      } else {
        // Might be xmlFragment + xmlFragment + xmlFragment + ...;
        // then the result will be an XMLList which we want to be an
        // rValue and allow it to be assigned to an lvalue.
        listToAdd = newXMLListFrom(obj1);
      }
    } else {
      listToAdd.addToList(obj1);
    }

    if (obj2 instanceof XMLList) {
      XMLList list2 = (XMLList) obj2;
      for (int i = 0; i < list2.length(); i++) {
        listToAdd.addToList(list2.item(i));
      }
    } else if (obj2 instanceof XML) {
      listToAdd.addToList(obj2);
    }

    return listToAdd;
  }
Пример #2
0
  @Override
  XMLList children() {
    ArrayList<XML> list = new ArrayList<XML>();

    for (int i = 0; i < length(); i++) {
      XML xml = getXmlFromAnnotation(i);

      if (xml != null) {
        XMLList childList = xml.children();

        int cChildren = childList.length();
        for (int j = 0; j < cChildren; j++) {
          list.add(childList.item(j));
        }
      }
    }

    XMLList allChildren = newXMLList();
    int sz = list.size();

    for (int i = 0; i < sz; i++) {
      allChildren.addToList(list.get(i));
    }

    return allChildren;
  }
Пример #3
0
  @Override
  boolean equivalentXml(Object target) {
    boolean result = false;

    // Zero length list should equate to undefined
    if (target instanceof Undefined && length() == 0) {
      result = true;
    } else if (length() == 1) {
      result = getXmlFromAnnotation(0).equivalentXml(target);
    } else if (target instanceof XMLList) {
      XMLList otherList = (XMLList) target;

      if (otherList.length() == length()) {
        result = true;

        for (int i = 0; i < length(); i++) {
          if (!getXmlFromAnnotation(i).equivalentXml(otherList.getXmlFromAnnotation(i))) {
            result = false;
            break;
          }
        }
      }
    }

    return result;
  }
Пример #4
0
    /** @deprecated */
    void addToList(Object toAdd) {
      if (toAdd instanceof Undefined) {
        // Missing argument do nothing...
        return;
      }

      if (toAdd instanceof XMLList) {
        XMLList xmlSrc = (XMLList) toAdd;
        for (int i = 0; i < xmlSrc.length(); i++) {
          this._add((xmlSrc.item(i)).getAnnotation());
        }
      } else if (toAdd instanceof XML) {
        this._add(((XML) (toAdd)).getAnnotation());
      } else if (toAdd instanceof XmlNode) {
        this._add((XmlNode) toAdd);
      }
    }
Пример #5
0
  @Override
  public void put(int index, Scriptable start, Object value) {
    Object parent = Undefined.instance;
    // Convert text into XML if needed.
    XMLObject xmlValue;

    // Special-case checks for undefined and null
    if (value == null) {
      value = "null";
    } else if (value instanceof Undefined) {
      value = "undefined";
    }

    if (value instanceof XMLObject) {
      xmlValue = (XMLObject) value;
    } else {
      if (targetProperty == null) {
        xmlValue = newXMLFromJs(value.toString());
      } else {
        //    Note that later in the code, we will use this as an argument to replace(int,value)
        //    So we will be "replacing" this element with itself
        //    There may well be a better way to do this
        //    TODO    Find a way to refactor this whole method and simplify it
        xmlValue = item(index);
        if (xmlValue == null) {
          XML x = item(0);
          xmlValue = x == null ? newTextElementXML(null, targetProperty, null) : x.copy();
        }
        ((XML) xmlValue).setChildren(value);
      }
    }

    // Find the parent
    if (index < length()) {
      parent = item(index).parent();
    } else if (length() == 0) {
      parent = targetObject != null ? targetObject.getXML() : parent();
    } else {
      // Appending
      parent = parent();
    }

    if (parent instanceof XML) {
      // found parent, alter doc
      XML xmlParent = (XML) parent;

      if (index < length()) {
        // We're replacing the the node.
        XML xmlNode = getXmlFromAnnotation(index);

        if (xmlValue instanceof XML) {
          replaceNode(xmlNode, (XML) xmlValue);
          replace(index, xmlNode);
        } else if (xmlValue instanceof XMLList) {
          // Replace the first one, and add the rest on the list.
          XMLList list = (XMLList) xmlValue;

          if (list.length() > 0) {
            int lastIndexAdded = xmlNode.childIndex();
            replaceNode(xmlNode, list.item(0));
            replace(index, list.item(0));

            for (int i = 1; i < list.length(); i++) {
              xmlParent.insertChildAfter(xmlParent.getXmlChild(lastIndexAdded), list.item(i));
              lastIndexAdded++;
              insert(index + i, list.item(i));
            }
          }
        }
      } else {
        // Appending
        xmlParent.appendChild(xmlValue);
        addToList(xmlParent.getLastXmlChild());
      }
    } else {
      // Don't all have same parent, no underlying doc to alter
      if (index < length()) {
        XML xmlNode = getXML(_annos, index);

        if (xmlValue instanceof XML) {
          replaceNode(xmlNode, (XML) xmlValue);
          replace(index, xmlNode);
        } else if (xmlValue instanceof XMLList) {
          // Replace the first one, and add the rest on the list.
          XMLList list = (XMLList) xmlValue;

          if (list.length() > 0) {
            replaceNode(xmlNode, list.item(0));
            replace(index, list.item(0));

            for (int i = 1; i < list.length(); i++) {
              insert(index + i, list.item(i));
            }
          }
        }
      } else {
        addToList(xmlValue);
      }
    }
  }