DocumentImpl.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.Iterator;

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

import com.arcle.rmt.rqml.*;
import com.arcle.rmt.j2se.model.RQMLDocument;
import com.arcle.rmt.j2se.model.RQMLDocumentUpdateEvent;
import com.arcle.rmt.j2se.model.RQMLDocumentUpdateConstants;

public class DocumentImpl extends RQMLDocument implements Observer,
        RQMLDocumentUpdateConstants {
    public DocumentImpl(org.w3c.dom.Element elem) {
        _elem = elem;
    }

    //-----------------------------------------------------------------------
    // Observer Implementation

    public void update(Observable o, Object arg) {
        if(o instanceof RQMLFirstClass) {
            setChanged();
            notifyObservers(o);
        }
    }

    //-----------------------------------------------------------------------
    // RQMLDocument Implementation

    public Requirement createRequirement() {
        return (Requirement) doCreateFirstClass("requirement");
    }

    public Stakeholder createStakeholder() {
        return (Stakeholder) doCreateFirstClass("stakeholder");
    }

    public Assumption createAssumption() {
        return (Assumption) doCreateFirstClass("assumption");
    }

    /*
    Creates a new Issue element.
    */
    public Issue createIssue() {
        return (Issue) doCreateFirstClass("issue");
    }

    public Taxonomy createTaxonomy() {
        return (Taxonomy) doCreateFirstClass("taxonomy");
    }

    public Context createContext() {
        return (Context) doCreateFirstClass("context");
    }

    public Lexicon createLexicon() {
        return (Lexicon) doCreateFirstClass("lexicon");
    }

    public Project createProject() {
        return (Project) doCreateFirstClass("project");
    }

    public Usecase createUsecase() {
        return (Usecase) doCreateFirstClass("use-case");
    }


    public Iterator getElements() {
        return new ElementIterator();
    }

    public void deleteElement(RQMLFirstClass elem) {
        notifyUpdate(ET_DELETING_ELEMENT, elem);
        ElementAdapter ea = (ElementAdapter) elem;
        deleteElement(ea.deleteElement());
        notifyUpdate(ET_ELEMENT_DELETED, null);
    }

    //-----------------------------------------------------------------------
    // Protected

    protected RQMLFirstClass doCreateFirstClass(String name) {
        RQMLFirstClass elem = (RQMLFirstClass) createElement(name);
        notifyUpdate(ET_NEW_ELEMENT, elem);
        return elem;
    }

    protected void deleteElement(Element elem) {
        if (elem == null) {
            return;
        }

        // remove from DOM
        try {
            Node parent = elem.getParentNode();
            if (parent != null) {
                parent.removeChild(elem);
            }
        } catch(DOMException e) {
            e.printStackTrace();
            // ignore
        }

        setChanged();
        _wrapperCache.remove(elem);
    }

    protected void notifyUpdate(int type, RQMLSecondClass elem) {
        setChanged();
        notifyObservers(createRQMLDocumentUpdateEvent(type, elem));
    }

    //-----------------------------------------------------------------------
    // Accessor Methods

    protected RQMLSecondClassFactory getElementFactory() {
        if (_wrapperCache == null) {
            _wrapperCache = createAdapterCacheFlyweight();
        }
        return _wrapperCache;
    }

    public org.w3c.dom.Element getRootElement() {
        return _elem;
    }

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

    protected RQMLSecondClass createElement(String elementName) {
        org.w3c.dom.Document doc = getRootElement().getOwnerDocument();
        Element elem = doc.createElement(elementName);
        getRootElement().appendChild(elem);
        setChanged();
        return getElementFactory().createRQMLSecondClass(elem);
    }

    protected AdapterCacheFlyweight createAdapterCacheFlyweight() {
        return new AdapterCacheFlyweight(this);
    }

    protected RQMLDocumentUpdateEvent createRQMLDocumentUpdateEvent(
            int type, RQMLSecondClass elem) {
        return new RQMLDocumentUpdateEvent(this, type, elem);
    }

    //-----------------------------------------------------------------------
    // Member variables.

    private org.w3c.dom.Element _elem;

    private AdapterCacheFlyweight _wrapperCache;

    //-----------------------------------------------------------------------
    // Inner Classes

    protected class ElementIterator implements Iterator {
        public ElementIterator() {
            currentElement = (Element) getRootElement().getFirstChild();
        }

        public boolean hasNext() {
            return currentElement != null;
        }

        public Object next() {
            if (currentElement != null) {
                RQMLFirstClass elem = (RQMLFirstClass) getElementFactory()
                    .createRQMLSecondClass(currentElement);
                currentElement = (Element) currentElement.getNextSibling();
                return elem;
            }
            return null;
        }

        public void remove() {
            Element dead = currentElement;
            currentElement = (Element)dead.getPreviousSibling();
            deleteElement(dead);
        }

        protected Element currentElement = null;
    }
}

---