    001// Licensed under the Apache License, Version 2.0 (the "License");
    002// you may not use this file except in compliance with the License.
    003// You may obtain a copy of the License at
    004//
    005// http://www.apache.org/licenses/LICENSE-2.0
    006//
    007// Unless required by applicable law or agreed to in writing, software
    008// distributed under the License is distributed on an "AS IS" BASIS,
    009// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    010// See the License for the specific language governing permissions and
    011// limitations under the License.
    012
    013package org.apache.tapestry5.dom;
    014
    015import org.apache.tapestry5.func.Predicate;
    016import org.apache.tapestry5.internal.TapestryInternalUtils;
    017import org.apache.tapestry5.internal.util.PrintOutCollector;
    018import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
    019import org.apache.tapestry5.ioc.internal.util.InternalUtils;
    020import org.apache.tapestry5.ioc.util.Stack;
    021
    022import java.io.PrintWriter;
    023import java.util.*;
    024
    025/**
    026 * An element that will render with a begin tag and attributes, a body, and an end tag. Also acts as a factory for
    027 * enclosed Element, Text and Comment nodes.
    028 *
    029 * TODO: Support for CDATA nodes. Do we need Entity nodes?
    030 */
    031public final class Element extends Node
    032{
    033
    034    private final String name;
    035
    036    private Node firstChild;
    037
    038    private Node lastChild;
    039
    040    private Attribute firstAttribute;
    041
    042    private final Document document;
    043
    044    /**
    045     * URI of the namespace which contains the element. A quirk in XML is that the element may be in a namespace it
    046     * defines itself, so resolving the namespace to a prefix must wait until render time (since the Element is created
    047     * before the namespaces for it are defined).
    048     */
    049    private final String namespace;
    050
    051    private Map<String, String> namespaceToPrefix;
    052
    053    /**
    054     * Constructor for a root element.
    055     */
    056    Element(Document container, String namespace, String name)
    057    {
    058        super(null);
    059
    060        document = container;
    061        this.namespace = namespace;
    062        this.name = name;
    063    }
    064
    065    /**
    066     * Constructor for a nested element.
    067     */
    068    Element(Element parent, String namespace, String name)
    069    {
    070        super(parent);
    071
    072        this.namespace = namespace;
    073        this.name = name;
    074
    075        document = null;
    076    }
    077
    078    @Override
    079    public Document getDocument()
    080    {
    081        return document != null ? document : super.getDocument();
    082    }
    083
    084    /**
    085     * Adds an attribute to the element, but only if the attribute name does not already exist.
    086     * The "class" attribute is treated specially: the new value is appended, after a space, to the
    087     * existing value.
    088     *
    089     * @param name
    090     *         the name of the attribute to add
    091     * @param value
    092     *         the value for the attribute. A value of null is allowed, and no attribute will be added to the
    093     *         element.
    094     */
    095    public Element attribute(String name, String value)
    096    {
    097        return attribute(null, name, value);
    098    }
    099
    100    /**
    101     * Adds a namespaced attribute to the element, but only if the attribute name does not already exist.
    102     * The "class" attribute of the default namespace is treated specially: the new value
    103     * is appended, after a space, to the existing value.
    104     *
    105     * @param namespace
    106     *         the namespace to contain the attribute, or null for the default namespace
    107     * @param name
    108     *         the name of the attribute to add
    109     * @param value
    110     *         the value for the attribute. A value of null is allowed, and no attribute will be added to the
    111     *         element.
    112     */
    113    public Element attribute(String namespace, String name, String value)
    114    {
    115        assert InternalUtils.isNonBlank(name);
    116
    117        updateAttribute(namespace, name, value, false);
    118
    119        return this;
    120    }
    121
    122    private void updateAttribute(String namespace, String name, String value, boolean force)
    123    {
    124        if (!force && value == null)
    125        {
    126            return;
    127        }
    128
    129        // TAP5-2660: handle empty namespace as the null one, since both represent no namespace
    130        if ("".equals(namespace))
    131        {
    132            namespace = null;
    133        }
    134
    135        Attribute prior = null;
    136        Attribute cursor = firstAttribute;
    137
    138        while (cursor != null)
    139        {
    140            if (cursor.matches(namespace, name))
    141            {
    142                boolean isClass = namespace == null && name.equals("class");
    143
    144                if (!(force || isClass))
    145                {
    146                    return;
    147                }
    148
    149                if (value != null)
    150                {
    151                    if (!force && isClass)
    152                    {
    153                        cursor.value += (" " + value);
    154                    } else
    155                    {
    156                        cursor.value = value;
    157                    }
    158
    159                    return;
    160                }
    161
    162                // Remove this Attribute node from the linked list
    163
    164                if (prior == null)
    165                {
    166                    firstAttribute = cursor.nextAttribute;
    167                } else
    168                {
    169                    prior.nextAttribute = cursor.nextAttribute;
    170                }
    171
    172                return;
    173            }
    174
    175            prior = cursor;
    176            cursor = cursor.nextAttribute;
    177        }
    178
    179        // Don't add an Attribute if the value is null.
    180
    181        if (value != null)
    182        {
    183            firstAttribute = new Attribute(this, namespace, name, value, firstAttribute);
    184        }
    185    }
    186
    187    /**
    188     * Convenience for invoking {@link #attribute(String, String)} multiple times.
    189     *
    190     * @param namesAndValues
    191     *         alternating attribute names and attribute values
    192     */
    193    public Element attributes(String... namesAndValues)
    194    {
    195        int i = 0;
    196        while (i < namesAndValues.length)
    197        {
    198            String name = namesAndValues[i++];
    199            String value = namesAndValues[i++];
    200
    201            attribute(name, value);
    202        }
    203
    204        return this;
    205    }
    206
    207    /**
    208     * Forces changes to a number of attributes. The new attributes <em>overwrite</em> previous values. Overriding an
    209     * attribute's value to null will remove the attribute entirely.
    210     *
    211     * @param namesAndValues
    212     *         alternating attribute names and attribute values
    213     * @return this element
    214     */
    215    public Element forceAttributes(String... namesAndValues)
    216    {
    217        return forceAttributesNS(null, namesAndValues);
    218    }
    219
    220    /**
    221     * Forces changes to a number of attributes in the global namespace. The new attributes <em>overwrite</em> previous
    222     * values (event for the "class" attribute). Overriding attribute's value to null will remove the attribute entirely.
    223     * TAP5-708: don't use element namespace for attributes
    224     *
    225     * @param namespace
    226     *         the namespace or null
    227     * @param namesAndValues
    228     *         alternating attribute name and value
    229     * @return this element
    230     */
    231    public Element forceAttributesNS(String namespace, String... namesAndValues)
    232    {
    233        int i = 0;
    234
    235        while (i < namesAndValues.length)
    236        {
    237            String name = namesAndValues[i++];
    238            String value = namesAndValues[i++];
    239
    240            updateAttribute(namespace, name, value, true);
    241        }
    242
    243        return this;
    244    }
    245
    246    /**
    247     * Creates and returns a new Element node as a child of this node.
    248     *
    249     * @param name
    250     *         the name of the element to create
    251     * @param namesAndValues
    252     *         alternating attribute names and attribute values
    253     */
    254    public Element element(String name, String... namesAndValues)
    255    {
    256        assert InternalUtils.isNonBlank(name);
    257        Element child = newChild(new Element(this, null, name));
    258
    259        child.attributes(namesAndValues);
    260
    261        return child;
    262    }
    263
    264    /**
    265     * Inserts a new element before this element.
    266     *
    267     * @param name
    268     *         element name
    269     * @param namesAndValues
    270     *         attribute names and values
    271     * @return the new element
    272     * @since 5.3
    273     */
    274    public Element elementBefore(String name, String... namesAndValues)
    275    {
    276        assert InternalUtils.isNonBlank(name);
    277
    278        Element sibling = container.element(name, namesAndValues);
    279
    280        sibling.moveBefore(this);
    281
    282        return sibling;
    283    }
    284
    285
    286    /**
    287     * Creates and returns a new Element within a namespace as a child of this node.
    288     *
    289     * @param namespace
    290     *         namespace to contain the element, or null
    291     * @param name
    292     *         element name to create within the namespace
    293     * @return the newly created element
    294     */
    295    public Element elementNS(String namespace, String name)
    296    {
    297        assert InternalUtils.isNonBlank(name);
    298        return newChild(new Element(this, namespace, name));
    299    }
    300
    301    /**
    302     * Creates a new element, as a child of the current index, at the indicated index.
    303     *
    304     * @param index
    305     *         to insert at
    306     * @param name
    307     *         element name
    308     * @param namesAndValues
    309     *         attribute name / attribute value pairs
    310     * @return the new element
    311     */
    312    public Element elementAt(int index, String name, String... namesAndValues)
    313    {
    314        assert InternalUtils.isNonBlank(name);
    315        Element child = new Element(this, null, name);
    316        child.attributes(namesAndValues);
    317
    318        insertChildAt(index, child);
    319
    320        return child;
    321    }
    322
    323    /**
    324     * Adds the comment and returns this element for further construction.
    325     */
    326    public Element comment(String text)
    327    {
    328        newChild(new Comment(this, text));
    329
    330        return this;
    331    }
    332
    333    /**
    334     * Adds the raw text and returns this element for further construction.
    335     */
    336    public Element raw(String text)
    337    {
    338        newChild(new Raw(this, text));
    339
    340        return this;
    341    }
    342
    343    /**
    344     * Adds and returns a new text node (the text node is returned so that {@link Text#write(String)} or [@link
    345     * {@link Text#writef(String, Object[])} may be invoked .
    346     *
    347     * @param text
    348     *         initial text for the node
    349     * @return the new Text node
    350     */
    351    public Text text(String text)
    352    {
    353        return newChild(new Text(this, text));
    354    }
    355
    356    /**
    357     * Adds and returns a new CDATA node.
    358     *
    359     * @param content
    360     *         the content to be rendered by the node
    361     * @return the newly created node
    362     */
    363    public CData cdata(String content)
    364    {
    365        return newChild(new CData(this, content));
    366    }
    367
    368    private <T extends Node> T newChild(T child)
    369    {
    370        addChild(child);
    371
    372        return child;
    373    }
    374
    375    @Override
    376    void toMarkup(Document document, PrintWriter writer, Map<String, String> containerNamespacePrefixToURI)
    377    {
    378        Map<String, String> localNamespacePrefixToURI = createNamespaceURIToPrefix(containerNamespacePrefixToURI);
    379
    380        MarkupModel markupModel = document.getMarkupModel();
    381
    382        StringBuilder builder = new StringBuilder();
    383
    384        String prefixedElementName = toPrefixedName(localNamespacePrefixToURI, namespace, name);
    385
    386        builder.append('<').append(prefixedElementName);
    387
    388        // Output order used to be alpha sorted, but now it tends to be the inverse
    389        // of the order in which attributes were added.
    390
    391        for (Attribute attr = firstAttribute; attr != null; attr = attr.nextAttribute)
    392        {
    393            attr.render(markupModel, builder, localNamespacePrefixToURI);
    394        }
    395
    396        // Next, emit namespace declarations for each namespace.
    397
    398        List<String> namespaces = InternalUtils.sortedKeys(namespaceToPrefix);
    399
    400        for (String namespace : namespaces)
    401        {
    402            if (namespace.equals(Document.XML_NAMESPACE_URI))
    403                continue;
    404
    405            String prefix = namespaceToPrefix.get(namespace);
    406
    407            builder.append(" xmlns");
    408
    409            if (!prefix.equals(""))
    410            {
    411                builder.append(':').append(prefix);
    412            }
    413
    414            builder.append('=');
    415            builder.append(markupModel.getAttributeQuote());
    416
    417            markupModel.encodeQuoted(namespace, builder);
    418
    419            builder.append(markupModel.getAttributeQuote());
    420        }
    421
    422        EndTagStyle style = markupModel.getEndTagStyle(name);
    423
    424        boolean hasChildren = hasChildren();
    425
    426        String close = (!hasChildren && style == EndTagStyle.ABBREVIATE) ? "/>" : ">";
    427
    428        builder.append(close);
    429
    430        writer.print(builder.toString());
    431
    432        if (hasChildren)
    433            writeChildMarkup(document, writer, localNamespacePrefixToURI);
    434
    435        if (hasChildren || style == EndTagStyle.REQUIRE)
    436        {
    437            // TAP5-471: Avoid use of printf().
    438            writer.print("</");
    439            writer.print(prefixedElementName);
    440            writer.print(">");
    441        }
    442    }
    443
    444    String toPrefixedName(Map<String, String> namespaceURIToPrefix, String namespace, String name)
    445    {
    446        if (namespace == null || namespace.equals(""))
    447            return name;
    448
    449        if (namespace.equals(Document.XML_NAMESPACE_URI))
    450            return "xml:" + name;
    451
    452        String prefix = namespaceURIToPrefix.get(namespace);
    453
    454        // This should never happen, because namespaces are automatically defined as needed.
    455
    456        if (prefix == null)
    457            throw new IllegalArgumentException(String.format("No prefix has been defined for namespace '%s'.",
    458                    namespace));
    459
    460        // The empty string indicates the default namespace which doesn't use a prefix.
    461
    462        if (prefix.equals(""))
    463            return name;
    464
    465        return prefix + ":" + name;
    466    }
    467
    468    /**
    469     * Tries to find an element under this element (including itself) whose id is specified.
    470     * Performs a width-first
    471     * search of the document tree.
    472     *
    473     * @param id
    474     *         the value of the id attribute of the element being looked for
    475     * @return the element if found. null if not found.
    476     */
    477    public Element getElementById(final String id)
    478    {
    479        return getElementByAttributeValue("id", id);
    480    }
    481
    482    /**
    483     * Tries to find an element under this element (including itself) whose given attribute has a given value.
    484     *
    485     * @param attributeName
    486     *         the name of the attribute of the element being looked for
    487     * @param attributeValue
    488     *         the value of the attribute of the element being looked for
    489     * @return the element if found. null if not found.
    490     * @since 5.2.3
    491     */
    492    public Element getElementByAttributeValue(final String attributeName, final String attributeValue)
    493    {
    494        assert attributeName != null;
    495        assert attributeValue != null;
    496
    497        return getElement(new Predicate<Element>()
    498        {
    499            public boolean accept(Element e)
    500            {
    501                String elementId = e.getAttribute(attributeName);
    502                return attributeValue.equals(elementId);
    503            }
    504        });
    505    }
    506
    507    /**
    508     * Tries to find an element under this element (including itself) accepted by the given predicate.
    509     *
    510     * @param predicate
    511     *         Predicate to accept the element
    512     * @return the element if found. null if not found.
    513     * @since 5.2.3
    514     */
    515    public Element getElement(Predicate<Element> predicate)
    516    {
    517        LinkedList<Element> queue = CollectionFactory.newLinkedList();
    518
    519        queue.add(this);
    520
    521        while (!queue.isEmpty())
    522        {
    523            Element e = queue.removeFirst();
    524
    525            if (predicate.accept(e))
    526                return e;
    527
    528            for (Element child : e.childElements())
    529            {
    530                queue.addLast(child);
    531            }
    532        }
    533
    534        // Exhausted the entire tree
    535
    536        return null;
    537    }
    538
    539    /**
    540     * Searchs for a child element with a particular name below this element. The path parameter is a slash separated
    541     * series of element names.
    542     */
    543    public Element find(String path)
    544    {
    545        assert InternalUtils.isNonBlank(path);
    546        Element search = this;
    547
    548        for (String name : TapestryInternalUtils.splitPath(path))
    549        {
    550            search = search.findChildWithElementName(name);
    551
    552            if (search == null)
    553                break;
    554        }
    555
    556        return search;
    557    }
    558
    559    private Element findChildWithElementName(String name)
    560    {
    561        for (Element child : childElements())
    562        {
    563            if (child.getName().equals(name))
    564                return child;
    565        }
    566
    567        // Not found.
    568
    569        return null;
    570    }
    571
    572    private Iterable<Element> childElements()
    573    {
    574        return new Iterable<Element>()
    575        {
    576            public Iterator<Element> iterator()
    577            {
    578                return new Iterator<Element>()
    579                {
    580                    private Node cursor = firstChild;
    581
    582                    {
    583                        advance();
    584                    }
    585
    586                    private void advance()
    587                    {
    588                        while (cursor != null)
    589                        {
    590                            if (cursor instanceof Element)
    591                                return;
    592
    593                            cursor = cursor.nextSibling;
    594                        }
    595                    }
    596
    597                    public boolean hasNext()
    598                    {
    599                        return cursor != null;
    600                    }
    601
    602                    public Element next()
    603                    {
    604                        Element result = (Element) cursor;
    605
    606                        cursor = cursor.nextSibling;
    607
    608                        advance();
    609
    610                        return result;
    611                    }
    612
    613                    public void remove()
    614                    {
    615                        throw new UnsupportedOperationException("remove() not supported.");
    616                    }
    617                };
    618            }
    619        };
    620    }
    621
    622    public String getAttribute(String attributeName)
    623    {
    624        for (Attribute attr = firstAttribute; attr != null; attr = attr.nextAttribute)
    625        {
    626            if (attr.getName().equalsIgnoreCase(attributeName))
    627                return attr.value;
    628        }
    629
    630        return null;
    631    }
    632
    633    public String getName()
    634    {
    635        return name;
    636    }
    637
    638    /**
    639     * Adds one or more CSS class names to the "class" attribute.
    640     *
    641     * @param classNames
    642     *         one or more CSS class names
    643     * @return the element for further configuration
    644     * @deprecated Deprecated in 5.4, as this is now special behavior for the "class" attribute.
    645     */
    646    public Element addClassName(String... classNames)
    647    {
    648        for (String name : classNames)
    649        {
    650            attribute("class", name);
    651        }
    652
    653        return this;
    654    }
    655
    656    /**
    657     * Defines a namespace for this element, mapping a URI to a prefix. This will affect how namespaced elements and
    658     * attributes nested within the element are rendered, and will also cause <code>xmlns:</code> attributes (to define
    659     * the namespace and prefix) to be rendered.
    660     *
    661     * @param namespace
    662     *         URI of the namespace
    663     * @param namespacePrefix
    664     *         prefix
    665     * @return this element
    666     */
    667    public Element defineNamespace(String namespace, String namespacePrefix)
    668    {
    669        assert namespace != null;
    670        assert namespacePrefix != null;
    671        if (namespace.equals(Document.XML_NAMESPACE_URI))
    672            return this;
    673
    674        if (namespaceToPrefix == null)
    675            namespaceToPrefix = CollectionFactory.newMap();
    676
    677        namespaceToPrefix.put(namespace, namespacePrefix);
    678
    679        return this;
    680    }
    681
    682    /**
    683     * Returns the namespace for this element (which is typically a URL). The namespace may be null.
    684     */
    685    public String getNamespace()
    686    {
    687        return namespace;
    688    }
    689
    690    /**
    691     * Removes an element; the element's children take the place of the node within its container.
    692     */
    693    public void pop()
    694    {
    695        // Have to be careful because we'll be modifying the underlying list of children
    696        // as we work, so we need a copy of the children.
    697
    698        List<Node> childrenCopy = CollectionFactory.newList(getChildren());
    699
    700        for (Node child : childrenCopy)
    701        {
    702            child.moveBefore(this);
    703        }
    704
    705        remove();
    706    }
    707
    708    /**
    709     * Removes all children from this element.
    710     *
    711     * @return the element, for method chaining
    712     */
    713    public Element removeChildren()
    714    {
    715        firstChild = null;
    716        lastChild = null;
    717
    718        return this;
    719    }
    720
    721    /**
    722     * Creates the URI to namespace prefix map for this element, which reflects namespace mappings from containing
    723     * elements. In addition, automatic namespaces are defined for any URIs that are not explicitly mapped (this occurs
    724     * sometimes in Ajax partial render scenarios).
    725     *
    726     * @return a mapping from namespace URI to namespace prefix
    727     */
    728    private Map<String, String> createNamespaceURIToPrefix(Map<String, String> containerNamespaceURIToPrefix)
    729    {
    730        MapHolder holder = new MapHolder(containerNamespaceURIToPrefix);
    731
    732        holder.putAll(namespaceToPrefix);
    733
    734        // result now contains all the mappings, including this element's.
    735
    736        // Add a mapping for the element's namespace.
    737
    738        if (InternalUtils.isNonBlank(namespace))
    739        {
    740
    741            // Add the namespace for the element as the default namespace.
    742
    743            if (!holder.getResult().containsKey(namespace))
    744            {
    745                defineNamespace(namespace, "");
    746                holder.put(namespace, "");
    747            }
    748        }
    749
    750        // And for any attributes that have a namespace.
    751
    752        for (Attribute attr = firstAttribute; attr != null; attr = attr.nextAttribute)
    753            addMappingIfNeeded(holder, attr.getNamespace());
    754
    755        return holder.getResult();
    756    }
    757
    758    private void addMappingIfNeeded(MapHolder holder, String namespace)
    759    {
    760        if (InternalUtils.isBlank(namespace))
    761            return;
    762
    763        Map<String, String> current = holder.getResult();
    764
    765        if (current.containsKey(namespace))
    766            return;
    767
    768        // A missing namespace.
    769
    770        Set<String> prefixes = CollectionFactory.newSet(holder.getResult().values());
    771
    772        // A clumsy way to find a unique id for the new namespace.
    773
    774        int i = 0;
    775        while (true)
    776        {
    777            String prefix = "ns" + i;
    778
    779            if (!prefixes.contains(prefix))
    780            {
    781                defineNamespace(namespace, prefix);
    782                holder.put(namespace, prefix);
    783                return;
    784            }
    785
    786            i++;
    787        }
    788    }
    789
    790    @Override
    791    protected Map<String, String> getNamespaceURIToPrefix()
    792    {
    793        MapHolder holder = new MapHolder();
    794
    795        List<Element> elements = CollectionFactory.newList(this);
    796
    797        Element cursor = container;
    798
    799        while (cursor != null)
    800        {
    801            elements.add(cursor);
    802            cursor = cursor.container;
    803        }
    804
    805        // Reverse the list, so that later elements will overwrite earlier ones.
    806
    807        Collections.reverse(elements);
    808
    809        for (Element e : elements)
    810            holder.putAll(e.namespaceToPrefix);
    811
    812        return holder.getResult();
    813    }
    814
    815    /**
    816     * Returns true if the element has no children, or has only text children that contain only whitespace.
    817     *
    818     * @since 5.1.0.0
    819     */
    820    public boolean isEmpty()
    821    {
    822        List<Node> children = getChildren();
    823
    824        if (children.isEmpty())
    825            return true;
    826
    827        for (Node n : children)
    828        {
    829            if (n instanceof Text)
    830            {
    831                Text t = (Text) n;
    832
    833                if (t.isEmpty())
    834                    continue;
    835            }
    836
    837            // Not a text node, or a non-empty text node, then the element isn't empty.
    838            return false;
    839        }
    840
    841        return true;
    842    }
    843
    844    /**
    845     * Depth-first visitor traversal of this Element and its Element children. The traversal order is the same as render
    846     * order.
    847     *
    848     * @param visitor
    849     *         callback
    850     * @since 5.1.0.0
    851     */
    852    public void visit(Visitor visitor)
    853    {
    854        Stack<Element> queue = CollectionFactory.newStack();
    855
    856        queue.push(this);
    857
    858        while (!queue.isEmpty())
    859        {
    860            Element e = queue.pop();
    861
    862            visitor.visit(e);
    863
    864            e.queueChildren(queue);
    865        }
    866    }
    867
    868    private void queueChildren(Stack<Element> queue)
    869    {
    870        if (firstChild == null)
    871            return;
    872
    873        List<Element> childElements = CollectionFactory.newList();
    874
    875        for (Node cursor = firstChild; cursor != null; cursor = cursor.nextSibling)
    876        {
    877            if (cursor instanceof Element)
    878                childElements.add((Element) cursor);
    879        }
    880
    881        Collections.reverse(childElements);
    882
    883        for (Element e : childElements)
    884            queue.push(e);
    885    }
    886
    887    void addChild(Node child)
    888    {
    889        child.container = this;
    890
    891        if (lastChild == null)
    892        {
    893            firstChild = child;
    894            lastChild = child;
    895            return;
    896        }
    897
    898        lastChild.nextSibling = child;
    899        lastChild = child;
    900    }
    901
    902    void insertChildAt(int index, Node newChild)
    903    {
    904        newChild.container = this;
    905
    906        if (index < 1)
    907        {
    908            newChild.nextSibling = firstChild;
    909            firstChild = newChild;
    910        } else
    911        {
    912            Node cursor = firstChild;
    913            for (int i = 1; i < index; i++)
    914            {
    915                cursor = cursor.nextSibling;
    916            }
    917
    918            newChild.nextSibling = cursor.nextSibling;
    919            cursor.nextSibling = newChild;
    920        }
    921
    922        if (index < 1)
    923            firstChild = newChild;
    924
    925        if (newChild.nextSibling == null)
    926            lastChild = newChild;
    927    }
    928
    929    boolean hasChildren()
    930    {
    931        return firstChild != null;
    932    }
    933
    934    void writeChildMarkup(Document document, PrintWriter writer, Map<String, String> namespaceURIToPrefix)
    935    {
    936        Node cursor = firstChild;
    937
    938        while (cursor != null)
    939        {
    940            cursor.toMarkup(document, writer, namespaceURIToPrefix);
    941
    942            cursor = cursor.nextSibling;
    943        }
    944    }
    945
    946    /**
    947     * @return the concatenation of the String representations {@link #toString()} of its children.
    948     */
    949    public final String getChildMarkup()
    950    {
    951        PrintOutCollector collector = new PrintOutCollector();
    952
    953        writeChildMarkup(getDocument(), collector.getPrintWriter(), null);
    954
    955        return collector.getPrintOut();
    956    }
    957
    958    /**
    959     * Returns an unmodifiable list of children for this element. Only {@link org.apache.tapestry5.dom.Element}s will
    960     * have children. Also, note that unlike W3C DOM, attributes are not represented as
    961     * {@link org.apache.tapestry5.dom.Node}s.
    962     *
    963     * @return unmodifiable list of children nodes
    964     */
    965    public List<Node> getChildren()
    966    {
    967        List<Node> result = CollectionFactory.newList();
    968        Node cursor = firstChild;
    969
    970        while (cursor != null)
    971        {
    972            result.add(cursor);
    973            cursor = cursor.nextSibling;
    974        }
    975
    976        return result;
    977    }
    978
    979    void remove(Node node)
    980    {
    981        Node prior = null;
    982        Node cursor = firstChild;
    983
    984        while (cursor != null)
    985        {
    986            if (cursor == node)
    987            {
    988                Node afterNode = node.nextSibling;
    989
    990                if (prior != null)
    991                    prior.nextSibling = afterNode;
    992                else
    993                    firstChild = afterNode;
    994
    995                // If node was the final node in the element then handle deletion.
    996                // It's even possible node was the only node in the container.
    997
    998                if (lastChild == node)
    999                {
    1000                    lastChild = prior != null ? prior : null;
    1001                }
    1002
    1003                node.nextSibling = null;
    1004
    1005                return;
    1006            }
    1007
    1008            prior = cursor;
    1009            cursor = cursor.nextSibling;
    1010        }
    1011
    1012        throw new IllegalArgumentException("Node to remove was not present as a child of this element.");
    1013    }
    1014
    1015    void insertChildBefore(Node existing, Node node)
    1016    {
    1017        int index = indexOfNode(existing);
    1018
    1019        node.container = this;
    1020
    1021        insertChildAt(index, node);
    1022    }
    1023
    1024    void insertChildAfter(Node existing, Node node)
    1025    {
    1026        Node oldAfter = existing.nextSibling;
    1027
    1028        existing.nextSibling = node;
    1029        node.nextSibling = oldAfter;
    1030
    1031        if (oldAfter == null)
    1032            lastChild = node;
    1033
    1034        node.container = this;
    1035    }
    1036
    1037    int indexOfNode(Node node)
    1038    {
    1039        int index = 0;
    1040        Node cursor = firstChild;
    1041
    1042        while (cursor != null)
    1043        {
    1044            if (node == cursor)
    1045                return index;
    1046
    1047            cursor = cursor.nextSibling;
    1048            index++;
    1049        }
    1050
    1051        throw new IllegalArgumentException("Node not a child of this element.");
    1052    }
    1053
    1054    /**
    1055     * Returns the attributes for this Element as a (often empty) collection of
    1056     * {@link org.apache.tapestry5.dom.Attribute}s. The order of the attributes within the collection is not specified.
    1057     * Modifying the collection will not affect the attributes (use {@link #forceAttributes(String[])} to change
    1058     * existing attribute values, and {@link #attribute(String, String, String)} to add new attribute values.
    1059     *
    1060     * @return attribute collection
    1061     */
    1062    public Collection<Attribute> getAttributes()
    1063    {
    1064        Collection<Attribute> result = CollectionFactory.newList();
    1065
    1066        for (Attribute a = firstAttribute; a != null; a = a.nextAttribute)
    1067        {
    1068            result.add(a);
    1069        }
    1070
    1071        return result;
    1072    }
    1073}