AdapterCacheFlyweight.java

Go to the documentation of this file.

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

import java.util.WeakHashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Observer;
import java.util.Observable;
import org.w3c.dom.Element;
import com.arcle.rmt.rqml.*;
import com.arcle.rmt.j2se.model.domimpl.rqml.*;
import com.arcle.rmt.j2se.util.CounterMap;
import com.arcle.rmt.j2se.util.StringUtilities;

public class AdapterCacheFlyweight implements RQMLSecondClassFactory {

    public AdapterCacheFlyweight(Observer elementObserver) {
        if (elementObserver == null) {
            throw new IllegalArgumentException(
                "Parameter 'elementObserver' cannot be null.");
        }
        _elementObserver = elementObserver;
    }

    public RQMLSecondClass createRQMLSecondClass(Element elem) {
        RQMLSecondClass rqml = (RQMLSecondClass) getCache().get(elem);
        if (rqml == null) {
            RQMLSecondClassFactory fac = getElementFactory(elem.getNodeName());
            if (fac == null) {
                throw new UnsupportedOperationException(
                    "Factory not found for element: " + elem.getNodeName());
            }
            rqml = fac.createRQMLSecondClass(elem);
            assignID(rqml);
            addObservable(rqml);
            getCache().put(elem, rqml);
        }
        return rqml;
    }

    public boolean remove(Element elem) {
        Object rqml = getCache().get(elem);
        if (rqml instanceof ElementAdapter) {
            ElementAdapter ea = (ElementAdapter) rqml;
            // since we use a WeakHashMap, all of its children adapters
            // will eventually die out from the cache.
            ea.deleteElement();
        }
        return getCache().remove(elem) != null;
    }


    protected boolean addObservable(Object o) {
        if (o instanceof Observable) {
            Observable obs = (Observable) o;
            obs.addObserver(getElementObserver());
            return true;
        }
        return false;
    }

    protected void assignID(RQMLSecondClass elem) {
        String id = elem.getID();
        String name = ((RQMLSecondClassImpl) elem).getElementName();
        String stripped = StringUtilities.stripAllExceptConsonantsOrFirstChar(name);
        int endIndex = Math.min(NAME_PREFIX_LEN, stripped.length());
        String prefix = stripped.substring(0, endIndex);
        /* To prevent ID clashes when two elements with different element
           names resolve to the same prefix, we use the prefix instead
           of the element name as the counter key.
           Even though we might not need the counter value, we increment
           the counter anyway to account those elements already
           having an ID.
        */
        int idValue = getElementIDGenerator().incrementCounter(prefix);
        if (id.length() == 0) {
            id =  prefix + "-" + idValue;
            elem.setID(id);
        }
    }


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

    protected Map getCache() {
        if (_cache == null) {
            _cache = createCache();
        }
        return _cache;
    }

    protected RQMLSecondClassFactory getElementFactory(String elementName) {
        if (_elementFactories == null) {
            _elementFactories = createElementFactories();
        }
        return _elementFactories.getFactory(elementName);
    }

    protected Observer getElementObserver() {
        return _elementObserver;
    }

    protected CounterMap getElementIDGenerator() {
        if (_IDGenerator == null) {
            _IDGenerator = createElementIDGenerator();
        }
        return _IDGenerator;
    }


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

    protected Map createCache() {
        return new WeakHashMap();
    }

    protected RQMLSecondClassFactoryFacade createElementFactories() {
        return new RQMLSecondClassFactoryFacade(this);
    }

    protected CounterMap createElementIDGenerator() {
        return new CounterMap();
    }

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

    private RQMLSecondClassFactoryFacade _elementFactories = null;

    private Map _cache = null;

    private Observer _elementObserver;

    private CounterMap _IDGenerator = null;

    protected static final int NAME_PREFIX_LEN = 4;

    //-----------------------------------------------------------------------
    // Inner classes

    protected abstract class ElementFactory implements RQMLSecondClassFactory {

        public RQMLSecondClass createRQMLSecondClass(Element e) {
            RQMLSecondClassImpl rcs = doCreateRQMLSecondClass(e);
            return rcs;
        }

        protected abstract RQMLSecondClassImpl doCreateRQMLSecondClass(Element e);
    }
}

---