plugins/org.eclipse.epsilon.emc.simulink/src/org/eclipse/epsilon/emc/simulink/model/SimulinkModel.java - epsilon/org.eclipse.epsilon - Git at Google

 /*********************************************************************
 * Copyright (c) 2008 The University of York.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 **********************************************************************/
 package org.eclipse.epsilon.emc.simulink.model;

 import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.Future;

 import org.eclipse.epsilon.common.util.Multimap;
 import org.eclipse.epsilon.common.util.StringProperties;
 import org.eclipse.epsilon.emc.simulink.engine.MatlabEngine;
 import org.eclipse.epsilon.emc.simulink.engine.MatlabEnginePool;
 import org.eclipse.epsilon.emc.simulink.exception.MatlabException;
 import org.eclipse.epsilon.emc.simulink.exception.MatlabRuntimeException;
 import org.eclipse.epsilon.emc.simulink.introspection.java.SimulinkPropertyGetter;
 import org.eclipse.epsilon.emc.simulink.introspection.java.SimulinkPropertySetter;
 import org.eclipse.epsilon.emc.simulink.model.TypeHelper.Kind;
 import org.eclipse.epsilon.emc.simulink.model.element.ISimulinkModelElement;
 import org.eclipse.epsilon.emc.simulink.model.element.SimulinkBlock;
 import org.eclipse.epsilon.emc.simulink.model.element.StateflowBlock;
 import org.eclipse.epsilon.emc.simulink.operations.contributors.ModelOperationContributor;
 import org.eclipse.epsilon.emc.simulink.util.MatlabEngineUtil;
 import org.eclipse.epsilon.emc.simulink.util.SimulinkUtil;
 import org.eclipse.epsilon.eol.exceptions.EolInternalException;
 import org.eclipse.epsilon.eol.exceptions.EolRuntimeException;
 import org.eclipse.epsilon.eol.exceptions.models.EolEnumerationValueNotFoundException;
 import org.eclipse.epsilon.eol.exceptions.models.EolModelElementTypeNotFoundException;
 import org.eclipse.epsilon.eol.exceptions.models.EolModelLoadingException;
 import org.eclipse.epsilon.eol.exceptions.models.EolNotInstantiableModelElementTypeException;
 import org.eclipse.epsilon.eol.execute.introspection.IPropertyGetter;
 import org.eclipse.epsilon.eol.execute.introspection.IPropertySetter;
 import org.eclipse.epsilon.eol.execute.operations.contributors.IOperationContributorProvider;
 import org.eclipse.epsilon.eol.execute.operations.contributors.OperationContributor;
 import org.eclipse.epsilon.eol.models.CachedModel;
 import org.eclipse.epsilon.eol.models.IRelativePathResolver;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class SimulinkModel extends CachedModel<ISimulinkModelElement> implements IOperationContributorProvider {

 	/** CONSTANTS */
 	public static final String PROPERTY_FILE = "file";
 	public static final String PROPERTY_LIBRARY_PATH = "library_path";
 	public static final String PROPERTY_ENGINE_JAR_PATH = "engine_jar_path";
 	public static final String PROPERTY_SHOW_IN_MATLAB_EDITOR = "hidden_editor";
 	public static final String PROPERTY_FOLLOW_LINKS = "follow_links";
 	public static final String PROPERTY_WORKING_DIR = "working_dir";

 	public static final String BLOCK = "Block";
 	public static final String SIMULINK = "Simulink";
 	public static final String STATEFLOW = "Stateflow";

 	public static final String PWD = "cd '?';";
 	public static final String GET_PARAM = "get_param('?', 'Handle');";
 	public static final String LOAD_SYSTEM = "load_system('?')";
 	public static final String OPEN_SYSTEM = "open_system('?')";
 	public static final String NEW_SYSTEM = "new_system('?', 'Model');";
 	public static final String SAVE_SYSTEM = "save_system('?', '?');";

 	private static final Logger LOGGER = LoggerFactory.getLogger(SimulinkModel.class);

 	//
 	private static final Multimap<String, String> createBlockMap = new Multimap<>();
 	//
 	private static final ArrayList<ArrayList<String>> deleteBlockMap = new ArrayList<>();

 	static {
 		createBlockMap.put("sflib/Chart", "Stateflow.Chart");
 		ArrayList<String> chart = new ArrayList<>();
 		chart.add("SubSystem");
 		chart.add("Stateflow.Chart");
 		deleteBlockMap.add(chart);
 	}

 	/** FIELDS */

 	protected File file = null;
 	protected SimulinkPropertyGetter propertyGetter;
 	protected SimulinkPropertySetter propertySetter;
 	protected ModelOperationContributor simulinkOperationContributor;

 	protected File workingDir = null;
 	protected String libraryPath;
 	protected String engineJarPath;
 	protected MatlabEngine engine;

 	protected boolean showInMatlabEditor = false;
 	protected boolean followLinks = true;
 	protected double handle = -1;

 	@Override
 	protected void loadModel() throws EolModelLoadingException {
 		try {
 			engine = MatlabEnginePool.getInstance(libraryPath, engineJarPath).getMatlabEngine();
 			simulinkOperationContributor = new ModelOperationContributor(engine);

 			if ((workingDir != null && workingDir.exists())) {
 				try {
 					engine.eval(PWD, workingDir);
 				} catch (Exception ex) {
 					LOGGER.info(ex.getMessage());
 				}
 			}

 			if (readOnLoad) {
 				String cmd = showInMatlabEditor ? OPEN_SYSTEM : LOAD_SYSTEM;
 				try{
 					engine.eval(cmd, file.getAbsolutePath());
 				} catch (Exception e) {
 					try {
 						engine.eval(NEW_SYSTEM, getSimulinkModelName());
 					} catch (Exception ex) {
 						// Ignore; system already exists
 					}
 				}
 			} else {
 				try {
 					engine.eval(NEW_SYSTEM, getSimulinkModelName());
 				} catch (Exception ex) {
 					// Ignore; system already exists
 				}
 			}

 			this.handle = (Double) engine.evalWithResult(GET_PARAM, getSimulinkModelName());
 		} catch (Exception e) {
 			throw new EolModelLoadingException(e, this);
 		}
 	}

 	@Override
 	protected void disposeModel() {
 		try {
 			MatlabEnginePool.getInstance(libraryPath, engineJarPath).release(engine);
 		} catch (MatlabRuntimeException e) {

 		}
 	}

 	@Override
 	protected ISimulinkModelElement createInstanceInModel(String type)
 			throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
 		if (type.contains("/")) {
 			try {
 				return new SimulinkBlock(this, engine, type);
 			} catch (MatlabRuntimeException e) {
 				throw new EolNotInstantiableModelElementTypeException(getSimulinkModelName(), type);
 			}
 		} else if (type.startsWith(STATEFLOW + ".")) {
 			try {
 				return new StateflowBlock(this, engine, type);
 			} catch (MatlabException e) {
 				throw new EolNotInstantiableModelElementTypeException(getSimulinkModelName(), type);
 			}
 		} else {
 			throw new EolModelElementTypeNotFoundException(type, null);
 		}
 	}

 	@Override
 	protected void addToCache(String type, ISimulinkModelElement instance) throws EolModelElementTypeNotFoundException {
 		for (String kind : getAllTypeNamesOf(instance)) {
 			Object kindCacheKey = getCacheKeyForType(kind);
 			kindCache.putIfPresent(kindCacheKey, instance);
 		}
 	}

 	@Override
 	protected void removeFromCache(ISimulinkModelElement instance) throws EolModelElementTypeNotFoundException {
 		for (String kind : getAllTypeNamesOf(instance)) {
 			final Object kindCacheKey = getCacheKeyForType(kind);
 			kindCache.remove(kindCacheKey, instance);
 		}
 	}

 	@Override
 	public void deleteElement(Object o) throws EolRuntimeException {
 		deleteElementInModel(o);
 		if (isCachingEnabled()) {
 			if (o instanceof ISimulinkModelElement) {
 				removeFromCache((ISimulinkModelElement) o);
 				String type = ((ISimulinkModelElement) o).getType();
 				for (List<String> specialType : deleteBlockMap) {
 					if (specialType.contains(type)) {
 						for (String equivalent : specialType) {
 							if (!equivalent.equals(type)) {
 								kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
 							}
 						}
 					}
 				}
 			}
 		}
 	}

 	@Override
 	public ISimulinkModelElement createInstance(String type)
 			throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
 		ISimulinkModelElement instance = createInstanceInModel(type);
 		if (isCachingEnabled()) {
 			addToCache(instance.getType(), instance);
 			if (createBlockMap.containsKey(type)){
 				for (String equivalent : createBlockMap.get(type)){
 					kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
 				}
 			}
 		}
 		return instance;
 	}

 	@Override
 	public Object createInstance(String type, Collection<Object> parameters)
 			throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
 		if (type.startsWith(STATEFLOW) && parameters.size() == 1) {
 			Object parentObject = parameters.toArray()[0];
 			try {
 				if (parentObject instanceof StateflowBlock) {
 					try {
 						StateflowBlock instance = new StateflowBlock(this, engine, type, (StateflowBlock) parentObject);
 						if (isCachingEnabled()) {
 							addToCache(instance.getType(), instance);
 							if (createBlockMap.containsKey(type)){
 								for (String equivalent : createBlockMap.get(type)){
 									kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
 								}
 							}
 						}
 						return instance;
 					} catch (MatlabException e) {
 						throw new EolModelElementTypeNotFoundException(type, null, e.getMessage());
 					}
 				} else {
 					throw new EolModelElementTypeNotFoundException(type, null, "invalid parameters");
 				}
 			} catch (EolRuntimeException e) {
 				throw new EolModelElementTypeNotFoundException(type, null, e.getMessage());
 			}
 		}
 		throw new EolModelElementTypeNotFoundException(type, null);
 	}

 	@Override
 	protected boolean deleteElementInModel(Object instance) throws EolRuntimeException {
 		try {
 			if (instance instanceof ISimulinkModelElement)
 				return ((ISimulinkModelElement) instance).deleteElementInModel();
 			return false;
 		} catch (Exception e) {
 			throw new EolInternalException(e);
 		}
 	}

 	@Override
 	protected Object getCacheKeyForType(String type) throws EolModelElementTypeNotFoundException {
 		return type;
 	}

 	// COLLECTORS

 	@Override
 	protected Collection<String> getAllTypeNamesOf(Object instance) {
 		if (instance instanceof ISimulinkModelElement) {
 			return ((ISimulinkModelElement) instance).getAllTypeNamesOf();
 		} else {
 			return Arrays.asList(getTypeNameOf(instance));
 		}
 	}

 	@Override
 	protected Collection<ISimulinkModelElement> allContentsFromModel() {
 		return TypeHelper.getAll(engine, this);
 	}

 	@Override // FIXME
 	protected Collection<ISimulinkModelElement> getAllOfTypeFromModel(String type)
 			throws EolModelElementTypeNotFoundException {
 		return TypeHelper.getAllOfType(this, engine, type);
 	}

 	@Override
 	protected Collection<ISimulinkModelElement> getAllOfKindFromModel(String kind)
 			throws EolModelElementTypeNotFoundException {
 		try {
 			try {
 				return Kind.get(kind).getAll(this);
 			} catch (Exception e) {
 				return getAllOfTypeFromModel(kind);
 			}
 		} catch (Exception e) {
 			throw new EolModelElementTypeNotFoundException(null, null);
 		}
 	}

 	public static void main(String[] args) throws Exception {
 		File tmpFile = File.createTempFile("foo", ".slx");

 		SimulinkModel model = new SimulinkModel();
 		model.setName("M");
 		model.setFile(tmpFile);
 		model.setWorkingDir(null);
 		model.setReadOnLoad(false);
 		model.setStoredOnDisposal(false);
 		model.setShowInMatlabEditor(true);
 		model.setFollowLinks(false);
 		//model.setEngineJarPath(MatlabEngineFilesEnum.ENGINE_JAR.path());
 		//model.setLibraryPath(MatlabEngineFilesEnum.LIBRARY_PATH.path());
 		model.load();
 		System.out.println(model.getAllOfType("Gain"));
 	}

 	public void load(StringProperties properties, IRelativePathResolver resolver) throws EolModelLoadingException {
 		super.load(properties, resolver);

 		String filePath = properties.getProperty(SimulinkModel.PROPERTY_FILE);
 		String workingDirPath = properties.getProperty(SimulinkModel.PROPERTY_WORKING_DIR);
 		if (properties.hasProperty(SimulinkModel.PROPERTY_LIBRARY_PATH))
 			libraryPath = properties.getProperty(SimulinkModel.PROPERTY_LIBRARY_PATH);
 		if (properties.hasProperty(SimulinkModel.PROPERTY_ENGINE_JAR_PATH))
 			engineJarPath = properties.getProperty(SimulinkModel.PROPERTY_ENGINE_JAR_PATH);
 		if (properties.hasProperty(SimulinkModel.PROPERTY_SHOW_IN_MATLAB_EDITOR))
 			showInMatlabEditor = properties.getBooleanProperty(SimulinkModel.PROPERTY_SHOW_IN_MATLAB_EDITOR, false);
 		if (properties.hasProperty(SimulinkModel.PROPERTY_FOLLOW_LINKS))
 			followLinks = properties.getBooleanProperty(SimulinkModel.PROPERTY_FOLLOW_LINKS, true);
 		if (filePath != null && filePath.trim().length() > 0)
 			file = new File(resolver.resolve(filePath));
 		if (workingDirPath != null && workingDirPath.trim().length() > 0) {
 			workingDir = new File(resolver.resolve(filePath));
 		}

 		load();
 	}

 	public void simulate() throws InterruptedException {
 		String name = getFile().getName().substring(0, getFile().getName().lastIndexOf("."));
 		Future<Void> fSim;
 		try {
 			fSim = engine.evalAsync("simout = sim('" + name + "', []);");
 			while (!fSim.isDone()) {
 				Thread.sleep(1000);
 			}
 		} catch (MatlabException e) {
 			e.printStackTrace();
 		}
 	}

 	@Override
 	public boolean hasType(String type) {
 		return true; // FIXME No validation?
 	}

 	@Override
 	public String getTypeNameOf(Object instance) {
 		if (instance instanceof ISimulinkModelElement) {
 			return ((ISimulinkModelElement) instance).getType();
 		}
 		return instance.getClass().getSimpleName().replace(SIMULINK, "");
 	}

 	@Override
 	public Object getElementById(String id) {
 		return null;
 	}

 	@Override
 	public void setElementId(Object instance, String newId) {
 	}

 	@Override
 	public String getElementId(Object instance) {
 		try {
 			return (String) propertyGetter.invoke(instance, "id");
 		} catch (EolRuntimeException e) {
 			return "";
 		}
 	}

 	@Override
 	public boolean owns(Object instance) {
 		if (instance == null) {
 			return false;
 		}
 		return ((instance instanceof ISimulinkModelElement)
 				&& ((ISimulinkModelElement) instance).getOwningModel() == this )
 				|| (instance instanceof SimulinkModel)
 				|| (instance.getClass().getCanonicalName().startsWith("org.eclipse.epsilon.emc.simulink.types"));
 	}

 	@Override
 	public boolean store(String location) {
 		try {
 			engine.eval(SAVE_SYSTEM, getSimulinkModelName(), location);
 			return true;
 		} catch (Exception e) {
 			return false;
 		}
 	}

 	@Override
 	public boolean store() {
 		store(file.getAbsolutePath());
 		return true;
 	}

 	@Override
 	public Object getEnumerationValue(String enumeration, String label) throws EolEnumerationValueNotFoundException {
 		throw new UnsupportedOperationException();
 	}

 	@Override
 	public boolean isInstantiable(String type) {
 		return hasType(type);
 	}

 	public String getSimulinkModelName() {
 		String name = file.getName();
 		int pos = name.lastIndexOf(".");
 		if (pos > 0) {
 			name = name.substring(0, pos);
 		}
 		return name;
 	}

 	@Override
 	public IPropertySetter getPropertySetter() {
 		if (propertySetter == null) {
 			propertySetter = new SimulinkPropertySetter(engine);
 		}
 		return propertySetter;
 	}

 	@Override
 	public IPropertyGetter getPropertyGetter() {
 		if (propertyGetter == null) {
 			propertyGetter = new SimulinkPropertyGetter();
 		}
 		return propertyGetter;
 	}

 	@Override
 	public OperationContributor getOperationContributor() {
 		return simulinkOperationContributor;
 	}

 	public File getFile() {
 		return file;
 	}

 	public void setFile(File file) {
 		this.file = file;
 	}

 	public MatlabEngine getEngine() {
 		return engine;
 	}

 	public Double getHandle() {
 		return handle;
 	}

 	public String getLibraryPath() {
 		return libraryPath;
 	}

 	public void setLibraryPath(String libraryPath) {
 		this.libraryPath = libraryPath;
 	}

 	public String getEngineJarPath() {
 		return engineJarPath;
 	}

 	public void setEngineJarPath(String engineJarPath) {
 		this.engineJarPath = engineJarPath;
 	}

 	public boolean isShowInMatlabEditor() {
 		return showInMatlabEditor;
 	}

 	public File getWorkingDir() {
 		return workingDir;
 	}

 	public void setWorkingDir(File workingDir) {
 		this.workingDir = workingDir;
 	}

 	/**
 	 * If true, the model will be shown in the MATLAB Editor.
 	 * If the model is already loaded, it will not open it again.
 	 * If false, the model will not be open in the MATLAB editor,
 	 * but won't close an already open model
 	 */
 	public void setShowInMatlabEditor(boolean openMatlabEditor) {
 		this.showInMatlabEditor = openMatlabEditor;
 	}

 	public boolean isFollowLinks() {
 		return followLinks;
 	}

 	/**
 	 * If true, adds the 'Follow_Link' parameter to the 'find_system' method in MATLAB
 	 */
 	public void setFollowLinks(boolean followLinks) {
 		this.followLinks = followLinks;
 	}

 	public Object parseMatlabEngineVariable(String variableName) throws MatlabException {
 		return MatlabEngineUtil.parseMatlabEngineVariable(engine, variableName);
 	}

 	public void statement(String statement) throws EolRuntimeException {
 		try{
 			engine.eval(statement);
 		} catch (MatlabException e) {
 			throw new EolRuntimeException(e.getMessage());
 		}
 	}

 	public Object statementWithResult(String statement) throws EolRuntimeException {
 		try{
 			return engine.evalWithResult(statement);
 		} catch (MatlabException e) {
 			throw new EolRuntimeException(e.getMessage());
 		}
 	}

 	public Object getWorkspaceVariable(String value) {
 		try {
 			return MatlabEngineUtil.parseMatlabEngineVariable(engine,value);
 		} catch (MatlabException e) {
 			e.printStackTrace();
 			return null;
 		}
 	}

 	public Collection<ISimulinkModelElement> getChildren() throws MatlabException {
 		return SimulinkUtil.findBlocks(this,1);
 	}

 	public Collection<ISimulinkModelElement> findBlocks() throws MatlabException{
 		return SimulinkUtil.findBlocks(this,1);
 	}

 	public Collection<ISimulinkModelElement> findBlocks(Integer depth) throws MatlabException {
 		return SimulinkUtil.findBlocks(this,depth);
 	}

 }
	/*********************************************************************
	* Copyright (c) 2008 The University of York.
	*
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	**********************************************************************/
	package org.eclipse.epsilon.emc.simulink.model;

	import java.io.File;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;
	import java.util.concurrent.Future;

	import org.eclipse.epsilon.common.util.Multimap;
	import org.eclipse.epsilon.common.util.StringProperties;
	import org.eclipse.epsilon.emc.simulink.engine.MatlabEngine;
	import org.eclipse.epsilon.emc.simulink.engine.MatlabEnginePool;
	import org.eclipse.epsilon.emc.simulink.exception.MatlabException;
	import org.eclipse.epsilon.emc.simulink.exception.MatlabRuntimeException;
	import org.eclipse.epsilon.emc.simulink.introspection.java.SimulinkPropertyGetter;
	import org.eclipse.epsilon.emc.simulink.introspection.java.SimulinkPropertySetter;
	import org.eclipse.epsilon.emc.simulink.model.TypeHelper.Kind;
	import org.eclipse.epsilon.emc.simulink.model.element.ISimulinkModelElement;
	import org.eclipse.epsilon.emc.simulink.model.element.SimulinkBlock;
	import org.eclipse.epsilon.emc.simulink.model.element.StateflowBlock;
	import org.eclipse.epsilon.emc.simulink.operations.contributors.ModelOperationContributor;
	import org.eclipse.epsilon.emc.simulink.util.MatlabEngineUtil;
	import org.eclipse.epsilon.emc.simulink.util.SimulinkUtil;
	import org.eclipse.epsilon.eol.exceptions.EolInternalException;
	import org.eclipse.epsilon.eol.exceptions.EolRuntimeException;
	import org.eclipse.epsilon.eol.exceptions.models.EolEnumerationValueNotFoundException;
	import org.eclipse.epsilon.eol.exceptions.models.EolModelElementTypeNotFoundException;
	import org.eclipse.epsilon.eol.exceptions.models.EolModelLoadingException;
	import org.eclipse.epsilon.eol.exceptions.models.EolNotInstantiableModelElementTypeException;
	import org.eclipse.epsilon.eol.execute.introspection.IPropertyGetter;
	import org.eclipse.epsilon.eol.execute.introspection.IPropertySetter;
	import org.eclipse.epsilon.eol.execute.operations.contributors.IOperationContributorProvider;
	import org.eclipse.epsilon.eol.execute.operations.contributors.OperationContributor;
	import org.eclipse.epsilon.eol.models.CachedModel;
	import org.eclipse.epsilon.eol.models.IRelativePathResolver;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	public class SimulinkModel extends CachedModel<ISimulinkModelElement> implements IOperationContributorProvider {

	/** CONSTANTS */
	public static final String PROPERTY_FILE = "file";
	public static final String PROPERTY_LIBRARY_PATH = "library_path";
	public static final String PROPERTY_ENGINE_JAR_PATH = "engine_jar_path";
	public static final String PROPERTY_SHOW_IN_MATLAB_EDITOR = "hidden_editor";
	public static final String PROPERTY_FOLLOW_LINKS = "follow_links";
	public static final String PROPERTY_WORKING_DIR = "working_dir";

	public static final String BLOCK = "Block";
	public static final String SIMULINK = "Simulink";
	public static final String STATEFLOW = "Stateflow";

	public static final String PWD = "cd '?';";
	public static final String GET_PARAM = "get_param('?', 'Handle');";
	public static final String LOAD_SYSTEM = "load_system('?')";
	public static final String OPEN_SYSTEM = "open_system('?')";
	public static final String NEW_SYSTEM = "new_system('?', 'Model');";
	public static final String SAVE_SYSTEM = "save_system('?', '?');";

	private static final Logger LOGGER = LoggerFactory.getLogger(SimulinkModel.class);

	//
	private static final Multimap<String, String> createBlockMap = new Multimap<>();
	//
	private static final ArrayList<ArrayList<String>> deleteBlockMap = new ArrayList<>();

	static {
	createBlockMap.put("sflib/Chart", "Stateflow.Chart");
	ArrayList<String> chart = new ArrayList<>();
	chart.add("SubSystem");
	chart.add("Stateflow.Chart");
	deleteBlockMap.add(chart);
	}

	/** FIELDS */

	protected File file = null;
	protected SimulinkPropertyGetter propertyGetter;
	protected SimulinkPropertySetter propertySetter;
	protected ModelOperationContributor simulinkOperationContributor;

	protected File workingDir = null;
	protected String libraryPath;
	protected String engineJarPath;
	protected MatlabEngine engine;

	protected boolean showInMatlabEditor = false;
	protected boolean followLinks = true;
	protected double handle = -1;

	@Override
	protected void loadModel() throws EolModelLoadingException {
	try {
	engine = MatlabEnginePool.getInstance(libraryPath, engineJarPath).getMatlabEngine();
	simulinkOperationContributor = new ModelOperationContributor(engine);

	if ((workingDir != null && workingDir.exists())) {
	try {
	engine.eval(PWD, workingDir);
	} catch (Exception ex) {
	LOGGER.info(ex.getMessage());
	}
	}

	if (readOnLoad) {
	String cmd = showInMatlabEditor ? OPEN_SYSTEM : LOAD_SYSTEM;
	try{
	engine.eval(cmd, file.getAbsolutePath());
	} catch (Exception e) {
	try {
	engine.eval(NEW_SYSTEM, getSimulinkModelName());
	} catch (Exception ex) {
	// Ignore; system already exists
	}
	}
	} else {
	try {
	engine.eval(NEW_SYSTEM, getSimulinkModelName());
	} catch (Exception ex) {
	// Ignore; system already exists
	}
	}

	this.handle = (Double) engine.evalWithResult(GET_PARAM, getSimulinkModelName());
	} catch (Exception e) {
	throw new EolModelLoadingException(e, this);
	}
	}

	@Override
	protected void disposeModel() {
	try {
	MatlabEnginePool.getInstance(libraryPath, engineJarPath).release(engine);
	} catch (MatlabRuntimeException e) {

	}
	}

	@Override
	protected ISimulinkModelElement createInstanceInModel(String type)
	throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
	if (type.contains("/")) {
	try {
	return new SimulinkBlock(this, engine, type);
	} catch (MatlabRuntimeException e) {
	throw new EolNotInstantiableModelElementTypeException(getSimulinkModelName(), type);
	}
	} else if (type.startsWith(STATEFLOW + ".")) {
	try {
	return new StateflowBlock(this, engine, type);
	} catch (MatlabException e) {
	throw new EolNotInstantiableModelElementTypeException(getSimulinkModelName(), type);
	}
	} else {
	throw new EolModelElementTypeNotFoundException(type, null);
	}
	}

	@Override
	protected void addToCache(String type, ISimulinkModelElement instance) throws EolModelElementTypeNotFoundException {
	for (String kind : getAllTypeNamesOf(instance)) {
	Object kindCacheKey = getCacheKeyForType(kind);
	kindCache.putIfPresent(kindCacheKey, instance);
	}
	}

	@Override
	protected void removeFromCache(ISimulinkModelElement instance) throws EolModelElementTypeNotFoundException {
	for (String kind : getAllTypeNamesOf(instance)) {
	final Object kindCacheKey = getCacheKeyForType(kind);
	kindCache.remove(kindCacheKey, instance);
	}
	}

	@Override
	public void deleteElement(Object o) throws EolRuntimeException {
	deleteElementInModel(o);
	if (isCachingEnabled()) {
	if (o instanceof ISimulinkModelElement) {
	removeFromCache((ISimulinkModelElement) o);
	String type = ((ISimulinkModelElement) o).getType();
	for (List<String> specialType : deleteBlockMap) {
	if (specialType.contains(type)) {
	for (String equivalent : specialType) {
	if (!equivalent.equals(type)) {
	kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
	}
	}
	}
	}
	}
	}
	}

	@Override
	public ISimulinkModelElement createInstance(String type)
	throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
	ISimulinkModelElement instance = createInstanceInModel(type);
	if (isCachingEnabled()) {
	addToCache(instance.getType(), instance);
	if (createBlockMap.containsKey(type)){
	for (String equivalent : createBlockMap.get(type)){
	kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
	}
	}
	}
	return instance;
	}

	@Override
	public Object createInstance(String type, Collection<Object> parameters)
	throws EolModelElementTypeNotFoundException, EolNotInstantiableModelElementTypeException {
	if (type.startsWith(STATEFLOW) && parameters.size() == 1) {
	Object parentObject = parameters.toArray()[0];
	try {
	if (parentObject instanceof StateflowBlock) {
	try {
	StateflowBlock instance = new StateflowBlock(this, engine, type, (StateflowBlock) parentObject);
	if (isCachingEnabled()) {
	addToCache(instance.getType(), instance);
	if (createBlockMap.containsKey(type)){
	for (String equivalent : createBlockMap.get(type)){
	kindCache.replaceValues(equivalent, getAllOfTypeFromModel(equivalent)); // refresh for type
	}
	}
	}
	return instance;
	} catch (MatlabException e) {
	throw new EolModelElementTypeNotFoundException(type, null, e.getMessage());
	}
	} else {
	throw new EolModelElementTypeNotFoundException(type, null, "invalid parameters");
	}
	} catch (EolRuntimeException e) {
	throw new EolModelElementTypeNotFoundException(type, null, e.getMessage());
	}
	}
	throw new EolModelElementTypeNotFoundException(type, null);
	}

	@Override
	protected boolean deleteElementInModel(Object instance) throws EolRuntimeException {
	try {
	if (instance instanceof ISimulinkModelElement)
	return ((ISimulinkModelElement) instance).deleteElementInModel();
	return false;
	} catch (Exception e) {
	throw new EolInternalException(e);
	}
	}

	@Override
	protected Object getCacheKeyForType(String type) throws EolModelElementTypeNotFoundException {
	return type;
	}

	// COLLECTORS

	@Override
	protected Collection<String> getAllTypeNamesOf(Object instance) {
	if (instance instanceof ISimulinkModelElement) {
	return ((ISimulinkModelElement) instance).getAllTypeNamesOf();
	} else {
	return Arrays.asList(getTypeNameOf(instance));
	}
	}

	@Override
	protected Collection<ISimulinkModelElement> allContentsFromModel() {
	return TypeHelper.getAll(engine, this);
	}

	@Override // FIXME
	protected Collection<ISimulinkModelElement> getAllOfTypeFromModel(String type)
	throws EolModelElementTypeNotFoundException {
	return TypeHelper.getAllOfType(this, engine, type);
	}

	@Override
	protected Collection<ISimulinkModelElement> getAllOfKindFromModel(String kind)
	throws EolModelElementTypeNotFoundException {
	try {
	try {
	return Kind.get(kind).getAll(this);
	} catch (Exception e) {
	return getAllOfTypeFromModel(kind);
	}
	} catch (Exception e) {
	throw new EolModelElementTypeNotFoundException(null, null);
	}
	}

	public static void main(String[] args) throws Exception {
	File tmpFile = File.createTempFile("foo", ".slx");

	SimulinkModel model = new SimulinkModel();
	model.setName("M");
	model.setFile(tmpFile);
	model.setWorkingDir(null);
	model.setReadOnLoad(false);
	model.setStoredOnDisposal(false);
	model.setShowInMatlabEditor(true);
	model.setFollowLinks(false);
	//model.setEngineJarPath(MatlabEngineFilesEnum.ENGINE_JAR.path());
	//model.setLibraryPath(MatlabEngineFilesEnum.LIBRARY_PATH.path());
	model.load();
	System.out.println(model.getAllOfType("Gain"));
	}

	public void load(StringProperties properties, IRelativePathResolver resolver) throws EolModelLoadingException {
	super.load(properties, resolver);

	String filePath = properties.getProperty(SimulinkModel.PROPERTY_FILE);
	String workingDirPath = properties.getProperty(SimulinkModel.PROPERTY_WORKING_DIR);
	if (properties.hasProperty(SimulinkModel.PROPERTY_LIBRARY_PATH))
	libraryPath = properties.getProperty(SimulinkModel.PROPERTY_LIBRARY_PATH);
	if (properties.hasProperty(SimulinkModel.PROPERTY_ENGINE_JAR_PATH))
	engineJarPath = properties.getProperty(SimulinkModel.PROPERTY_ENGINE_JAR_PATH);
	if (properties.hasProperty(SimulinkModel.PROPERTY_SHOW_IN_MATLAB_EDITOR))
	showInMatlabEditor = properties.getBooleanProperty(SimulinkModel.PROPERTY_SHOW_IN_MATLAB_EDITOR, false);
	if (properties.hasProperty(SimulinkModel.PROPERTY_FOLLOW_LINKS))
	followLinks = properties.getBooleanProperty(SimulinkModel.PROPERTY_FOLLOW_LINKS, true);
	if (filePath != null && filePath.trim().length() > 0)
	file = new File(resolver.resolve(filePath));
	if (workingDirPath != null && workingDirPath.trim().length() > 0) {
	workingDir = new File(resolver.resolve(filePath));
	}

	load();
	}

	public void simulate() throws InterruptedException {
	String name = getFile().getName().substring(0, getFile().getName().lastIndexOf("."));
	Future<Void> fSim;
	try {
	fSim = engine.evalAsync("simout = sim('" + name + "', []);");
	while (!fSim.isDone()) {
	Thread.sleep(1000);
	}
	} catch (MatlabException e) {
	e.printStackTrace();
	}
	}

	@Override
	public boolean hasType(String type) {
	return true; // FIXME No validation?
	}

	@Override
	public String getTypeNameOf(Object instance) {
	if (instance instanceof ISimulinkModelElement) {
	return ((ISimulinkModelElement) instance).getType();
	}
	return instance.getClass().getSimpleName().replace(SIMULINK, "");
	}

	@Override
	public Object getElementById(String id) {
	return null;
	}

	@Override
	public void setElementId(Object instance, String newId) {
	}

	@Override
	public String getElementId(Object instance) {
	try {
	return (String) propertyGetter.invoke(instance, "id");
	} catch (EolRuntimeException e) {
	return "";
	}
	}

	@Override
	public boolean owns(Object instance) {
	if (instance == null) {
	return false;
	}
	return ((instance instanceof ISimulinkModelElement)
	&& ((ISimulinkModelElement) instance).getOwningModel() == this )
	\|\| (instance instanceof SimulinkModel)
	\|\| (instance.getClass().getCanonicalName().startsWith("org.eclipse.epsilon.emc.simulink.types"));
	}

	@Override
	public boolean store(String location) {
	try {
	engine.eval(SAVE_SYSTEM, getSimulinkModelName(), location);
	return true;
	} catch (Exception e) {
	return false;
	}
	}

	@Override
	public boolean store() {
	store(file.getAbsolutePath());
	return true;
	}

	@Override
	public Object getEnumerationValue(String enumeration, String label) throws EolEnumerationValueNotFoundException {
	throw new UnsupportedOperationException();
	}

	@Override
	public boolean isInstantiable(String type) {
	return hasType(type);
	}

	public String getSimulinkModelName() {
	String name = file.getName();
	int pos = name.lastIndexOf(".");
	if (pos > 0) {
	name = name.substring(0, pos);
	}
	return name;
	}

	@Override
	public IPropertySetter getPropertySetter() {
	if (propertySetter == null) {
	propertySetter = new SimulinkPropertySetter(engine);
	}
	return propertySetter;
	}

	@Override
	public IPropertyGetter getPropertyGetter() {
	if (propertyGetter == null) {
	propertyGetter = new SimulinkPropertyGetter();
	}
	return propertyGetter;
	}

	@Override
	public OperationContributor getOperationContributor() {
	return simulinkOperationContributor;
	}

	public File getFile() {
	return file;
	}

	public void setFile(File file) {
	this.file = file;
	}

	public MatlabEngine getEngine() {
	return engine;
	}

	public Double getHandle() {
	return handle;
	}

	public String getLibraryPath() {
	return libraryPath;
	}

	public void setLibraryPath(String libraryPath) {
	this.libraryPath = libraryPath;
	}

	public String getEngineJarPath() {
	return engineJarPath;
	}

	public void setEngineJarPath(String engineJarPath) {
	this.engineJarPath = engineJarPath;
	}

	public boolean isShowInMatlabEditor() {
	return showInMatlabEditor;
	}

	public File getWorkingDir() {
	return workingDir;
	}

	public void setWorkingDir(File workingDir) {
	this.workingDir = workingDir;
	}

	/**
	* If true, the model will be shown in the MATLAB Editor.
	* If the model is already loaded, it will not open it again.
	* If false, the model will not be open in the MATLAB editor,
	* but won't close an already open model
	*/
	public void setShowInMatlabEditor(boolean openMatlabEditor) {
	this.showInMatlabEditor = openMatlabEditor;
	}

	public boolean isFollowLinks() {
	return followLinks;
	}

	/**
	* If true, adds the 'Follow_Link' parameter to the 'find_system' method in MATLAB
	*/
	public void setFollowLinks(boolean followLinks) {
	this.followLinks = followLinks;
	}

	public Object parseMatlabEngineVariable(String variableName) throws MatlabException {
	return MatlabEngineUtil.parseMatlabEngineVariable(engine, variableName);
	}

	public void statement(String statement) throws EolRuntimeException {
	try{
	engine.eval(statement);
	} catch (MatlabException e) {
	throw new EolRuntimeException(e.getMessage());
	}
	}

	public Object statementWithResult(String statement) throws EolRuntimeException {
	try{
	return engine.evalWithResult(statement);
	} catch (MatlabException e) {
	throw new EolRuntimeException(e.getMessage());
	}
	}

	public Object getWorkspaceVariable(String value) {
	try {
	return MatlabEngineUtil.parseMatlabEngineVariable(engine,value);
	} catch (MatlabException e) {
	e.printStackTrace();
	return null;
	}
	}

	public Collection<ISimulinkModelElement> getChildren() throws MatlabException {
	return SimulinkUtil.findBlocks(this,1);
	}

	public Collection<ISimulinkModelElement> findBlocks() throws MatlabException{
	return SimulinkUtil.findBlocks(this,1);
	}

	public Collection<ISimulinkModelElement> findBlocks(Integer depth) throws MatlabException {
	return SimulinkUtil.findBlocks(this,depth);
	}

	}