ElementEditFactoryFacade.java

Go to the documentation of this file.

package com.arcle.rmt.j2se.swing.vc.rqml;

import java.util.Map;
import java.util.Hashtable;
import java.lang.ref.SoftReference;

import com.arcle.rmt.rqml.RQMLFirstClass;
import com.arcle.rmt.rqml.Requirement;
import com.arcle.rmt.rqml.Stakeholder;
import com.arcle.rmt.rqml.Issue;
import com.arcle.rmt.rqml.Assumption;
import com.arcle.rmt.rqml.Taxonomy;
import com.arcle.rmt.rqml.Context;
import com.arcle.rmt.rqml.Lexicon;
import com.arcle.rmt.rqml.Project;
import com.arcle.rmt.rqml.Usecase;

import com.arcle.rmt.j2se.swing.vc.ElementEditFactory;
import com.arcle.rmt.j2se.swing.vc.ElementEdit;
import com.arcle.rmt.j2se.util.GenericClassMap;
import com.arcle.rmt.j2se.util.ClassMapVisitor;

public final class ElementEditFactoryFacade implements ElementEditFactory {
    private ElementEditFactoryFacade () {  }

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

    public static synchronized ElementEditFactory getInstance() {
        if (_instance == null) {
            _instance = new ElementEditFactoryFacade();
        }
        return _instance;
    }

    protected synchronized ElementEditFactories getFactories() {
        ElementEditFactories fac = (ElementEditFactories) _factories.get();
        if (fac == null) {
            fac = createElementEditFactories();
            _factories = new SoftReference(fac);
        }
        return fac;
    }

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

    public ElementEdit createElementEdit(final RQMLFirstClass elem) {
        ElementEditFactory factory =
            (ElementEditFactory) getFactories().findFirstInstance(elem);
        if (factory == null) {
            throw new UnsupportedOperationException(
                "Unknown editor class for element: " + elem);
        }
        return factory.createElementEdit(elem);
    }


    protected ElementEditFactories createElementEditFactories() {
        return new ElementEditFactories();
    }


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

    private static ElementEditFactoryFacade _instance = null;

    private SoftReference _factories = new SoftReference(null);

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


    protected class ElementEditFactories extends GenericClassMap {
        protected Map createMappings() {
            Map nodes = new Hashtable(11, 1);

            nodes.put(Stakeholder.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new StakeholderEdit(elem);
                }
            });

            nodes.put(Requirement.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new RequirementEdit(elem);
                }
            });

            nodes.put(Issue.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new IssueEdit(elem);
                }
            });

            nodes.put(Assumption.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new AssumptionEdit(elem);
                }
            });

            nodes.put(Taxonomy.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new TaxonomyEdit(elem);
                }
            });

            nodes.put(Context.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new ContextEdit(elem);
                }
            });

            nodes.put(Lexicon.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new LexiconEdit(elem);
                }
            });

            nodes.put(Project.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new ProjectEdit(elem);
                }
            });

            nodes.put(Usecase.class, new ElementEditFactory() {
                public ElementEdit createElementEdit(RQMLFirstClass elem) {
                    return new UsecaseEdit(elem);
                }
            });

            return nodes;
        }
    }
}

---