modelgen/org.eclipse.stem.model.codegen/templates/editor/RelativeValueProviderAdapterFactory.javajet

<%@ jet package="org.eclipse.emf.codegen.ecore.templates.editor" imports="org.eclipse.stem.model.codegen.* org.eclipse.emf.codegen.ecore.genmodel.*" class="RelativeValueProviderAdapterFactory" version="" %>
<%
/**
 * <copyright>
 *
 * Copyright (c) 2012 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM - Initial API and implementation
 *
 * </copyright>
 */
%>
<%
STEMGenPackage stemGenPackage = (STEMGenPackage)((Object[])argument)[0]; 
GenPackage genPackage = stemGenPackage.getGenPackage(); 
GenModel genModel=genPackage.getGenModel();
String itemProviderFactoryClassName = genModel.getImportedName(genPackage.getProviderPackageName() +"."+ genPackage.getItemProviderAdapterFactoryClassName());
String relativeValueProviderAdapterFactoryClassName = genModel.getImportedName("org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProviderAdapterFactory");

String integrationLabelClassName = genModel.getImportedName("org.eclipse.stem.core.graph.IntegrationLabel");
String integrationLabelValueClassName = genModel.getImportedName("org.eclipse.stem.core.graph.IntegrationLabelValue");
String relativeValueProviderClassName = genModel.getImportedName("org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProvider");
//String relativeValueProviderAdapterClassName = genModel.getImportedName("org.eclipse.stem.definitions.adapters.relativevalue.RelativeValueProviderAdapter");

String dmLabelValueClassName = genModel.getImportedName("org.eclipse.stem.diseasemodels.standard.DiseaseModelLabelValue");
%>
<%@ include file="../Header.javajetinc"%>
package <%=genPackage.getPresentationPackageName()%>;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.provider.ChangeNotifier;
import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.IChangeNotifier;
import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
import org.eclipse.emf.edit.provider.IItemPropertySource;
import org.eclipse.emf.edit.provider.INotifyChangedListener;
import org.eclipse.emf.edit.ui.provider.PropertySource;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
<%genModel.markImportLocation(stringBuffer);%>

/**
 * @generated
 */
public class <%=genPackage.getPrefix()%>RelativeValueProviderAdapterFactory extends
		<%=genModel.getImportedName(genPackage.getUtilitiesPackageName()+"."+genPackage.getAdapterFactoryClassName())%> 
		implements <%=genModel.getImportedName("org.eclipse.ui.IStartup")%>, <%=relativeValueProviderAdapterFactoryClassName%> {
	
	/**
	 * This keeps track of the root adapter factory that delegates to this
	 * adapter factory.
	 */
	protected ComposedAdapterFactory parentAdapterFactory;

	/**
	 * This is used to implement
	 * {@link org.eclipse.emf.edit.provider.IChangeNotifier}.
	 */
	protected IChangeNotifier changeNotifier = new ChangeNotifier();

	/**
	 * This factory is used to create item providers for the adapted classes.
	 * The item providers are used as property sources to get the properties
	 * that can have relative values.
	 */
	private static <%=itemProviderFactoryClassName%> itemProviderFactory;	
	
	
	/**
	 * @generated
	 */
	public <%=genPackage.getPrefix()%>RelativeValueProviderAdapterFactory() {
		super();
		<%=relativeValueProviderAdapterFactoryClassName%>.INSTANCE.addAdapterFactory(this);
	}

	/**
	 * @generated
	 */
	public void earlyStartup() {
		new <%=genPackage.getPrefix()%>RelativeValueProviderAdapterFactory();
	}

	/**
	 * @see org.eclipse.emf.edit.provider.IChangeNotifier#addListener(org.eclipse.emf.edit.provider.INotifyChangedListener)
	 * @generated
	 */
	public void addListener(INotifyChangedListener notifyChangedListener) {
		changeNotifier.addListener(notifyChangedListener);
	} // addListener

	/**
	 * @see org.eclipse.emf.edit.provider.IChangeNotifier#fireNotifyChanged(org.eclipse.emf.common.notify.Notification)
	 * @generated
	 */
	public void fireNotifyChanged(Notification notification) {
		changeNotifier.fireNotifyChanged(notification);
		if (parentAdapterFactory != null) {
			parentAdapterFactory.fireNotifyChanged(notification);
		}
	} // fireNotifyChanged

	/**
	 * @see org.eclipse.emf.edit.provider.IChangeNotifier#removeListener(org.eclipse.emf.edit.provider.INotifyChangedListener)
	 * @generated
	 */
	public void removeListener(INotifyChangedListener notifyChangedListener) {
		changeNotifier.removeListener(notifyChangedListener);
	} // removeListener

	/**
	 * @see org.eclipse.emf.edit.provider.ComposeableAdapterFactory#getRootAdapterFactory()
	 * @generated
	 */
	public ComposeableAdapterFactory getRootAdapterFactory() {
		return parentAdapterFactory == null ? this : parentAdapterFactory
				.getRootAdapterFactory();
	} // getRootAdapterFactory

	/**
	 * @see org.eclipse.emf.edit.provider.ComposeableAdapterFactory#setParentAdapterFactory(org.eclipse.emf.edit.provider.ComposedAdapterFactory)
	 * @generated
	 */
	public void setParentAdapterFactory(
			ComposedAdapterFactory parentAdapterFactory) {
		this.parentAdapterFactory = parentAdapterFactory;
	} // setParentAdapterFactory

	/**
	 * This disposes all of the item providers created by this factory.
	 * 
	 * @see org.eclipse.emf.edit.provider.IDisposable#dispose()
	 * @generated
	 */
	public void dispose() {
		// Nothing
	} // dispose

	/**
	 * @generated
	 */
	@Override
	public boolean isFactoryForType(Object type) {
		return super.isFactoryForType(type)
				|| type == <%=relativeValueProviderClassName%>.class;
	}

	/**
	 * @return the instance of the Relative Value Provider Adapter Factory
	 * @generated
	 */
	private static <%=relativeValueProviderAdapterFactoryClassName%> getRelativeValueProviderAdapterFactory() {
		return <%=relativeValueProviderAdapterFactoryClassName%>.INSTANCE;
	}

	/**
	 * @return the instance of the Standard Item Provider factory.
	 * @generated
	 */
	private static <%=itemProviderFactoryClassName%> getItemProviderFactory() {
		if (itemProviderFactory == null) {
			itemProviderFactory = new <%=itemProviderFactoryClassName%>();
		}
		return itemProviderFactory;
	}

 <%/* Generates the adapter methods for each integration label EClass */%>
 <%for (STEMGenClass stemGenClass : stemGenPackage.getIntegrationLabelClasses()){%>
	/**
	 * @generated
	 */
	@Override
	public Adapter create<%=stemGenClass.getGenClass().getName() %>Adapter() {
		return new <%=stemGenClass.getGenClass().getName()%>RelativeValueProviderAdapter();
	}
	
 <%}%>
 
 <%/* Generates the adapter methods for each integration label EClass */%>
 <%for (STEMGenClass stemGenClass : stemGenPackage.getIntegrationLabelValueClasses()){%>
	/**
	 * @generated
	 */
	@Override
	public Adapter create<%=stemGenClass.getGenClass().getName() %>Adapter() {
		return new <%=stemGenClass.getGenClass().getName()%>RelativeValueProviderAdapter();
	}
	
 <%}%>

 <%/* Generate the adapter class for each integration label EClass */%>
 <%for (STEMGenClass stemGenClass : stemGenPackage.getIntegrationLabelClasses()){%>
	/**
	 * @generated
	 */
	public static class <%=stemGenClass.getGenClass().getName()%>RelativeValueProviderAdapter 
		extends <%=genModel.getImportedName(stemGenClass.getLabelRelativeValueProviderSuperClassName())%> {
	
		/**
		 * @generated
		 */
		private <%=integrationLabelValueClassName%> getCurrentLabelValue() {
			return (<%=integrationLabelValueClassName%>)((<%=integrationLabelClassName%>)getTarget()).getCurrentValue();
		}

		/**
		 * @generated
		 */
		private <%=relativeValueProviderClassName%> getCurrentLabelValueRelativeValueProvider() {
			return (<%=relativeValueProviderClassName%>)getRelativeValueProviderAdapterFactory()
				.adapt(getCurrentLabelValue(), <%=relativeValueProviderClassName%>.class);
		} 

		/**
		 * @generated
		 */
		@Override
		public List<IItemPropertyDescriptor> getProperties() {
			return getCurrentLabelValueRelativeValueProvider().getProperties();
		}

  <%if("DiseaseModel".equals(stemGenClass.getDescriptor().getModelType())){%>
		/**
		 * @generated
		 */
		@Override
		public double getRelativeValue(final EStructuralFeature feature) {
			return getCurrentLabelValueRelativeValueProvider().getRelativeValue(feature);
		}
  
  		/**
		 * @generated
		 */
		@Override
		public double getDenominator(final EStructuralFeature feature) {
			return ((<%=dmLabelValueClassName%>)getCurrentLabelValue()).getPopulationCount();
		}  
  <%}else{%>
		/**
		 * @generated
		 */
		@Override
		public double getRelativeValue(final EStructuralFeature feature) {
			return super.getRelativeValue(feature);
		}
  
  		/**
		 * @generated
		 */
		@Override
		public double getDenominator(final EStructuralFeature feature) {
			//return 1.0;
			return super.getDenominator(feature);
		}
  <%}//endif%>
	}

 <%}//endfor%>

 <%/* Generates the adapter methods for each integration label EClass */%>
 <%for (STEMGenClass stemGenClass : stemGenPackage.getIntegrationLabelValueClasses()){%>
	/**
	 * @generated
	 */
	public static class <%=stemGenClass.getGenClass().getName()%>RelativeValueProviderAdapter 
		extends <%=genModel.getImportedName(stemGenClass.getLabelValueRelativeValueProviderSuperClassName())%> {

		/**
		 * @generated
		 */
		@Override
		public List<IItemPropertyDescriptor> getProperties() {
			final IItemPropertySource propertySource = (IItemPropertySource)getItemProviderFactory()
					.adapt(getTarget(), PropertySource.class);

			final List<IItemPropertyDescriptor> properties = new ArrayList<IItemPropertyDescriptor>();
			for (IItemPropertyDescriptor descriptor : propertySource.getPropertyDescriptors(null)) {
				final EStructuralFeature feature = (EStructuralFeature) descriptor
						.getFeature(null);
				if (!(feature instanceof EReference)) {
					properties.add(descriptor);
				}
			}
			return properties;
		}

   <%if("DiseaseModel".equals(stemGenClass.getDescriptor().getModelType())){%>
		/**
		 * @generated
		 */
		@Override
		public double getRelativeValue(final EStructuralFeature feature) {
			final IntegrationLabelValue labelValue = (IntegrationLabelValue)getTarget();
			final double stateCount = labelValue.eGetDouble(feature.getFeatureID());
			final double denominator = getDenominator(feature);
			if (denominator <= 0.0) {
				return 0.0;
			}
			return stateCount / denominator;
		}
		
		/**
		 * @generated
		 */
		@Override
		public double getDenominator(final EStructuralFeature feature) {
			return ((<%=dmLabelValueClassName%>)getTarget()).getPopulationCount();
		}
   <%}else{%>
		/**
		 * @generated
		 */
		@Override
		public double getRelativeValue(final EStructuralFeature feature) {
			return super.getRelativeValue(feature);
		}
  
  		/**
		 * @generated
		 */
		@Override
		public double getDenominator(final EStructuralFeature feature) {
			//return 1.0;
			return super.getDenominator(feature);
		}
   <%}//endif%>
	}

 <%}//endfor%>
}
<%genModel.emitSortedImports();%>