ElementAdapter.java

Go to the documentation of this file.

package com.arcle.rmt.j2se.model.domimpl;

import java.util.Observable;
import java.util.Observer;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.lang.ref.WeakReference;

import org.w3c.dom.Element;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.DOMException;

import com.arcle.rmt.rqml.*;

public class ElementAdapter extends Observable implements Observer {

    public ElementAdapter(Element elem, RQMLSecondClassFactory factory) {
        _elem = new WeakReference(elem);
        _factory = factory;
    }

    public Element deleteElement() {
        // call child nodes.
        if (hasChildren()) {
            Iterator iter = getChildren().iterator();
            while (iter.hasNext()) {
                Object child = iter.next();
                if (child instanceof ElementAdapter) {
                    ElementAdapter ea = (ElementAdapter) child;
                    ea.deleteElement();
                }
                // don't assume Observable instance
                // When the child is not a subclass of ElementAdapter,
                // the following will also work.
                if (child instanceof Observable) {
                    Observable obs = (Observable) child;
                    obs.deleteObserver(this);
                }
            }
        }
        deleteObservers();
        return getElement();
    }

    public String getElementName() {
        return getElement().getTagName();
    }


    //-----------------------------------------------------------------------
    // Observer implementation

    public void update(Observable child, Object param) {
        if (!broadcasting) {
            // propagate only when the child update is not a result
            // of a broadcast by this' notifyObservers()
            setChanged();
            notifyObservers(param);
        }
    }

    //-----------------------------------------------------------------------
    // Observable implementation

    public void notifyObservers(Object arg) {
        super.notifyObservers(arg);
        broadcasting = true;
        try {
            Iterator iter = getChildren().iterator();
            while (iter.hasNext()) {
                Object child = iter.next();
                if (child instanceof Observable) {
                    Observable obs = (Observable) child;
                    obs.notifyObservers(arg);
                }
            }
        } finally {
            broadcasting = false;
        }
    }

    //-----------------------------------------------------------------------
    // Overridden from Object

    public int hashCode() {
        return getElement().hashCode();
    }

    public boolean equals(Object other) {
        if (other instanceof ElementAdapter) {
            ElementAdapter ea = (ElementAdapter) other;
            return getElement().equals(ea.getElement());
        }
        return false;
    }

    //-----------------------------------------------------------------------

    protected Element getElement() {
        return (Element) _elem.get();
    }

    protected RQMLSecondClassFactory getFactory() {
        return _factory;
    }

    //-----------------------------------------------------------------------

    protected RQMLSecondClass getFirstChild(String name) {
        return getFirstChild(name, true);
    }

    protected RQMLSecondClass getFirstChild(String name, boolean forceCreate) {
        NodeList children = getElement().getChildNodes();
        for (int i=0; i<children.getLength(); i++) {
            Node child = children.item(i);
            if (child instanceof Element && name.equals(child.getNodeName())) {
                return getFactory().createRQMLSecondClass((Element) child);
            }
        }
        // child not found
        if (forceCreate) {
            return createChild(name);
        }
        return null;
    }

    //-----------------------------------------------------------------------
    // Factory Methods

    protected RQMLSecondClass createChild(String name) {
        Element elem = getElement();
        org.w3c.dom.Document doc = elem.getOwnerDocument();
        Element child = doc.createElement(name);
        RQMLSecondClass rqml;
        elem.appendChild(child);
        rqml = getFactory().createRQMLSecondClass(child);
        if (rqml instanceof Observable) {
            Observable obs = (Observable) rqml;
            obs.addObserver(this);
        }
        getChildren().add(rqml);
        setChanged();
        return rqml;
    }

    protected String getAttribute(String name) {
        String attr = getElement().getAttribute(name);
        return (attr != null) ? attr : "";
    }

    protected void setAttribute(String name, String value) {
        getElement().setAttribute(name, value);
        setChanged();
    }

    protected boolean hasChildren() {
        return _children != null && !_children.isEmpty();
    }

    protected Set getChildren() {
        if (_children == null) {
            _children = new HashSet();
        }
        return _children;
    }

    //-----------------------------------------------------------------------
    // Member Variables

    private RQMLSecondClassFactory _factory;

    private WeakReference _elem;

    private Set _children = null;

    private boolean broadcasting = false;
}

---