ComposerRegistry.java

package org.reuseware.air.coconut;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;

public class ComposerRegistry {
	
	public static final String EP_OPERATORDEFINITION_ID = "org.reuseware.coconut.composer";
	
	private static ComposerRegistry instance;
	
	private Map<EClass, IComplexOperator> complexOperatorImplementations;
	private Map<EClass, IParameterWrapper> operatorParameterWrappers;

	
	private ComposerRegistry() throws CoreException{
		complexOperatorImplementations = new HashMap<EClass, IComplexOperator>();
		operatorParameterWrappers = new HashMap<EClass, IParameterWrapper>();
		loadCompositionOperators();
	}
	
	public static ComposerRegistry getInstance() throws CoreException{
		if(instance==null)
			instance = new ComposerRegistry();
		return instance;
	}
	
	private void loadCompositionOperators() throws CoreException{
		IExtensionPoint interpreterExtensionPoint = Platform.getExtensionRegistry().getExtensionPoint(EP_OPERATORDEFINITION_ID); 
		if (interpreterExtensionPoint != null) {
			IConfigurationElement[] interpreterPoints = interpreterExtensionPoint.getConfigurationElements(); 
			for (int i = 0; i < interpreterPoints.length; i++) {
				String language = interpreterPoints[i].getAttribute("language");
				// composition operator implementation class
				IComplexOperator interpreter = 
					(IComplexOperator) interpreterPoints[i].createExecutableExtension("operators"); 

				// composition operator parameter wrapper implementation class  
				IParameterWrapper wrapper = 
					(IParameterWrapper) interpreterPoints[i].createExecutableExtension("wrapper"); 

				IConfigurationElement[] children = interpreterPoints[i].getChildren("construct"); 
				for (int j = 0; j < children.length; j++) {

					String construct = 	children[j].getAttribute("name"); 

					// store and associate defined operator with language construct  
					addComplexOperator(language, construct, interpreter);

					// store information about wrapper 
					addWrapper(language, construct, wrapper); 
				}
			}
		}

	}
	
	/**
	 * Stores a complex operator definition corresponding to a language construct
	 * 
	 * @param language - the language namespace URI
	 * @param construct - the specific construct
	 * @param operator - the operator implementation
	 */
	private void addComplexOperator(String language, String construct, IComplexOperator operator) {
	    EPackage ePackage = EPackage.Registry.INSTANCE.getEPackage(language);
	    EClass eClass = (EClass) ePackage.getEClassifier(construct);
	    addComplexOperator(eClass, operator);  
	}


	private void addComplexOperator(EClass construct, IComplexOperator operator) {
		complexOperatorImplementations.put(construct, operator);
	}


	/**
     * Retrieves a complex operator 
     */
    public IComplexOperator getComplexOperator(EClass construct) {   	
    	if (complexOperatorImplementations.containsKey(construct))
    		return complexOperatorImplementations.get(construct);
    	return null;
    }

    /**
     * Stores information about a composition operator parameter wrapper
     */
    private void addWrapper(String language, String construct, IParameterWrapper wrapper) {
	    EPackage ePackage = EPackage.Registry.INSTANCE.getEPackage(language);
	    EClass eClass = (EClass) ePackage.getEClassifier(construct);
	    addWrapper(eClass, wrapper);  
    }
    
    /**
     * Stores information about a composition operator parameter wrapper
     * 
     * @param construct
     * @param wrapper
     */
    private void addWrapper(EClass construct, IParameterWrapper wrapper) {
    	operatorParameterWrappers.put(construct, wrapper);
    }

    
    /**
     * Retrieves a composition operator parameter wrapper 
     * 
     * @param language
     * @return
     */
    public IParameterWrapper getWrapper(EClass construct) {    	
    	return operatorParameterWrappers.get(construct); 
    }
    
    public Map<EClass, IComplexOperator> getComplexOperatorMap() {		
		return complexOperatorImplementations;
	}



}