/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * The contents of this file are subject to the Netscape Public * License Version 1.1 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.mozilla.org/NPL/ * * Software distributed under the License is distributed on an "AS * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or * implied. See the License for the specific language governing * rights and limitations under the License. * * The Original Code is Rhino code, released * May 6, 1999. * * The Initial Developer of the Original Code is Netscape * Communications Corporation.  Portions created by Netscape are * Copyright (C) 1997-2000 Netscape Communications Corporation. All * Rights Reserved. * * Contributor(s): * Ethan Hugg * Terry Lucas * Milen Nankov * * Alternatively, the contents of this file may be used under the * terms of the GNU Public License (the "GPL"), in which case the * provisions of the GPL are applicable instead of those above. * If you wish to allow use of your version of this file only * under the terms of the GPL and not to allow others to use your * version of this file under the NPL, indicate your decision by * deleting the provisions above and replace them with the notice * and other provisions required by the GPL.  If you do not delete * the provisions above, a recipient may use your version of this * file under either the NPL or the GPL. */package org.mozilla.javascript.xmlimpl;import java.util.Vector;import org.mozilla.javascript.*;import org.mozilla.javascript.xml.*;import org.apache.xmlbeans.XmlCursor;class XMLList extends XMLObjectImpl implements Function{    static final long serialVersionUID = -4543618751670781135L;    static class AnnotationList    {        private Vector v;        AnnotationList ()        {            v = new Vector();        }        void add (XML.XScriptAnnotation n)        {            v.add(n);        }        XML.XScriptAnnotation item(int index)        {            return (XML.XScriptAnnotation)(v.get(index));        }        void remove (int index)        {            v.remove(index);        }        int length()        {            return v.size();        }    };    // Fields    private AnnotationList    _annos;    private XMLObjectImpl targetObject = null;    private javax.xml.namespace.QName targetProperty = null;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    //    //  Constructors    //    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    /**     *     */    XMLList(XMLLibImpl lib)    {        super(lib, lib.xmlListPrototype);        _annos = new AnnotationList();    }    /**     *     * @param inputObject     */    XMLList(XMLLibImpl lib, Object inputObject)    {        super(lib, lib.xmlListPrototype);        String frag;        if (inputObject == null || inputObject instanceof Undefined)        {            frag = "";        }        else if (inputObject instanceof XML)        {            XML xml = (XML) inputObject;            _annos = new AnnotationList();            _annos.add(xml.getAnnotation());        }        else if (inputObject instanceof XMLList)        {            XMLList xmll = (XMLList) inputObject;            _annos = new AnnotationList();            for (int i = 0; i < xmll._annos.length(); i++)            {                _annos.add(xmll._annos.item(i));            }        }        else        {            frag = ScriptRuntime.toString(inputObject).trim();            if (!frag.startsWith("<>"))            {                frag = "<>" + frag + "</>";            }            frag = "<fragment>" + frag.substring(2);            if (!frag.endsWith("</>"))            {                throw ScriptRuntime.typeError("XML with anonymous tag missing end anonymous tag");            }            frag = frag.substring(0, frag.length() - 3) + "</fragment>";            XML orgXML = XML.createFromJS(lib, frag);            // Now orphan the children and add them to our XMLList.            XMLList children = (XMLList)orgXML.children();            _annos = new AnnotationList();            for (int i = 0; i < children._annos.length(); i++)            {                // Copy here is so that they'll be orphaned (parent() will be undefined)                _annos.add(((XML) children.item(i).copy()).getAnnotation());            }        }    }    //    //    // TargetObject/Property accessors    //    //    /**     *     * @param object     * @param property     */    void setTargets(XMLObjectImpl object, javax.xml.namespace.QName property)    {        targetObject = object;        targetProperty = property;    }////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    //    //  Private functions    //    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    /**     *     * @param index     * @return     */    XML getXmlFromAnnotation(int index)    {        XML retVal;        if (index >= 0 && index < length())        {            XML.XScriptAnnotation anno = _annos.item(index);            retVal = XML.getFromAnnotation(lib, anno);        }        else        {            retVal = null;        }        return retVal;    }    /**     *     * @param index     */    private void internalRemoveFromList (int index)    {        _annos.remove(index);    }    /**     *     * @param index     * @param xml     */    void replace(int index, XML xml)    {        if (index < length())        {            AnnotationList newAnnoList = new AnnotationList();            // Copy upto item to replace.            for (int i = 0; i < index; i++)            {                newAnnoList.add(_annos.item(i));            }            newAnnoList.add(xml.getAnnotation());            // Skip over old item we're going to replace we've already add new item on above line.            for (int i = index + 1; i < length(); i++)            {                newAnnoList.add(_annos.item(i));            }            _annos = newAnnoList;        }    }    /**     *     * @param index     * @param xml     */    private void insert(int index, XML xml)    {        if (index < length())        {            AnnotationList newAnnoList = new AnnotationList();            // Copy upto item to insert.            for (int i = 0; i < index; i++)            {                newAnnoList.add(_annos.item(i));            }            newAnnoList.add(xml.getAnnotation());            for (int i = index; i < length(); i++)            {                newAnnoList.add(_annos.item(i));            }            _annos = newAnnoList;        }    }    //    //    //  methods overriding ScriptableObject    //    //    public String getClassName ()    {        return "XMLList";    }    //    //    //  methods overriding IdScriptableObject    //    //    /**     *     * @param index     * @param start     * @return     */    public Object get(int index, Scriptable start)    {        //Log("get index: " + index);        if (index >= 0 && index < length())        {            return getXmlFromAnnotation(index);        }        else        {            return Scriptable.NOT_FOUND;        }    }    /**     *     * @param name     * @param start     * @return     */    boolean hasXMLProperty(XMLName xmlName)    {        boolean result = false;        // Has now should return true if the property would have results > 0 or        // if it's a method name        String name = xmlName.localName();        if ((getPropertyList(xmlName).length() > 0) ||            (getMethod(name) != NOT_FOUND))        {            result = true;        }        return result;    }    /**     *     * @param index     * @param start     * @return     */    public boolean has(int index, Scriptable start)    {        return 0 <= index && index < length();    }    /**     *     * @param name     * @param value     */    void putXMLProperty(XMLName xmlName, Object value)    {        //Log("put property: " + name);        // Special-case checks for undefined and null        if (value == null)        {            value = "null";        }        else if (value instanceof Undefined)        {            value = "undefined";        }        if (length() > 1)        {            throw ScriptRuntime.typeError("Assignment to lists with more that one item is not supported");        }        else if (length() == 0)        {            // Secret sauce for super-expandos.            // We set an element here, and then add ourselves to our target.            if (targetObject != null &&                targetProperty != null &&                !targetProperty.getLocalPart().equals("*"))            {                // Add an empty element with our targetProperty name and then set it.                XML xmlValue = XML.createTextElement(lib, targetProperty, "");                addToList(xmlValue);                if(xmlName.isAttributeName())                {                    setAttribute(xmlName, value);                }                else                {                    XML xml = (XML)item(0);                    xml.putXMLProperty(xmlName, value);                    // Update the list with the new item at location 0.                    replace(0, (XML)item(0));                }                // Now add us to our parent                XMLName name2 = XMLName.formProperty(targetProperty.getNamespaceURI(), targetProperty.getLocalPart());                targetObject.putXMLProperty(name2, this);            }            else            {                throw ScriptRuntime.typeError("Assignment to empty XMLList without targets not supported");            }        }        else if(xmlName.isAttributeName())        {            setAttribute(xmlName, value);        }        else        {            XML xml = (XML)item(0);            xml.putXMLProperty(xmlName, value);            // Update the list with the new item at location 0.            replace(0, (XML)item(0));        }    }    /**     *     * @param name     * @return     */    Object getXMLProperty(XMLName name)    {        return getPropertyList(name);    }    /**     *     * @param index     * @param value     */    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 = XML.createFromJS(lib, value.toString());            }            else            {                xmlValue = XML.createTextElement(lib, targetProperty, value.toString());            }        }        // Find the parent        if (index < length())        {            parent = item(index).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)                {                    xmlNode.replaceAll((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();                        xmlNode.replaceAll((XML)list.item(0));                        replace(index, (XML)list.item(0));                        for (int i = 1; i < list.length(); i++)                        {                            xmlParent.insertChildAfter(xmlParent.getXmlChild(lastIndexAdded), list.item(i));                            lastIndexAdded++;                            insert(index + i, (XML)list.item(i));                        }                    }                }            }            else            {                // Appending                xmlParent.appendChild(xmlValue);                addToList(xmlParent.getXmlChild(index));            }        }        else        {            // Don't all have same parent, no underlying doc to alter            if (index < length())            {                XML xmlNode = XML.getFromAnnotation(lib, _annos.item(index));                if (xmlValue instanceof XML)                {                    xmlNode.replaceAll((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;