bundles/core/org.eclipse.apogy.core.topology/src-gen-custom/org/eclipse/apogy/core/topology/impl/ApogyEnvironmentNodeCustomImpl.java

/*******************************************************************************
 * Copyright (c) 2018 Agence spatiale canadienne / Canadian Space Agency 
 * 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:
 *     Pierre Allard,
 *     Regent L'Archeveque - initial API and implementation
 *
 * SPDX-License-Identifier: EPL-1.0
 *******************************************************************************/
package org.eclipse.apogy.core.topology.impl;

import org.eclipse.apogy.core.ApogyCoreFactory;
import org.eclipse.apogy.core.ResultsListNode;
import org.eclipse.apogy.core.environment.AbstractWorksite;
import org.eclipse.apogy.core.environment.ApogyCoreEnvironmentPackage;
import org.eclipse.apogy.core.environment.ApogyEnvironment;
import org.eclipse.apogy.core.environment.Worksite;
import org.eclipse.apogy.core.environment.WorksiteNode;
import org.eclipse.apogy.core.invocator.ApogyCoreInvocatorPackage;
import org.eclipse.apogy.core.invocator.Context;
import org.eclipse.apogy.core.invocator.ResultsList;
import org.eclipse.apogy.core.topology.ApogyCoreTopologyFactory;
import org.eclipse.apogy.core.topology.ApogySystemAPIsNode;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;

public class ApogyEnvironmentNodeCustomImpl extends ApogyEnvironmentNodeImpl {

	private Adapter adapter = null;

	@Override
	public void setApogyEnvironment(ApogyEnvironment newApogyEnvironment) {
		updateApogyEnvironment(getApogyEnvironment(), newApogyEnvironment);
		super.setApogyEnvironment(newApogyEnvironment);
	}

	public void setWorksiteNode(WorksiteNode newWorksiteNode) {
		// Detach previous worksite node if applicable.
		if (getWorksiteNode() != null)
			getChildren().remove(getWorksiteNode());

		// Attache new worksite node if applicable.
		if (newWorksiteNode != null)
			getChildren().add(newWorksiteNode);

		super.setWorksiteNode(newWorksiteNode);
	}

	@Override
	public ResultsListNode getResultsListNode() {
		if (super.getResultsListNode() == null) {
			this.resultsListNode = ApogyCoreFactory.eINSTANCE.createResultsListNode();
			this.resultsListNode.setDescription("Results" + getNodeId());
			this.resultsListNode.setNodeId("RESULTS");

			// Attaches the results.
			getReferencedChildren().add(this.resultsListNode);
			this.resultsListNode.setParent(this);
		}

		return super.getResultsListNode();
	}


	@Override
	public ApogySystemAPIsNode getApogySystemAPIsNode() {
		if (super.getApogySystemAPIsNode() == null) {
			this.apogySystemAPIsNode = ApogyCoreTopologyFactory.eINSTANCE.createApogySystemAPIsNode();
			this.apogySystemAPIsNode.setNodeId("APOGY_SYSTEMS");
			this.apogySystemAPIsNode.setDescription("Root node of all Apogy Systems topologies.");

			// Attaches the Systems
			getChildren().add(this.apogySystemAPIsNode);

			this.apogySystemAPIsNode.setApogyEnvironment(getApogyEnvironment());
		}

		return super.getApogySystemAPIsNode();
	}

	@Override
	public void dispose() {
		setApogyEnvironment(null);

		getWorksiteNode().setWorksite(null);
		setWorksiteNode(null);

		getResultsListNode().setResultsList(null);

		getApogySystemAPIsNode().setApogyEnvironment(null);

		getChildren().clear();

	}

	private void updateApogyEnvironment(ApogyEnvironment oldApogyEnvironment, ApogyEnvironment newApogyEnvironment) {
		ResultsList oldResultsList = null;
		ResultsList newResultsList = null;

		AbstractWorksite oldWorksite = null;
		AbstractWorksite newWorksite = null;

		if (oldApogyEnvironment != null) {
			// Unregister from old environment, if applicable.
			oldApogyEnvironment.eAdapters().remove(getAdapter());

			// Gets the old worksite.
			oldWorksite = oldApogyEnvironment.getActiveWorksite();

			// If the Context was set
			if (oldApogyEnvironment.getActiveContext() != null) {
				if (oldApogyEnvironment.getActiveContext().getDataProductsList() != null) {
					oldResultsList = oldApogyEnvironment.getActiveContext().getDataProductsList()
							.getOperationCallResultsList();
				}
			}
		}

		// Sets up the newEnvironement
		if (newApogyEnvironment != null) {
			if (newApogyEnvironment.getName() != null) {
				setNodeId(newApogyEnvironment.getName());
			}

			setDescription("Apogy Environment Node");
			setNodeId("APOGY_ENVIRONMENT");

			// Gets the new Worksite.
			newWorksite = newApogyEnvironment.getActiveWorksite();

			// Register listener to the new ApogyEnvironment.
			newApogyEnvironment.eAdapters().add(getAdapter());

			// If the context is set.
			if (newApogyEnvironment.getActiveContext() != null) {
				newResultsList = newApogyEnvironment.getActiveContext().getDataProductsList()
						.getOperationCallResultsList();
			}
		}

		// Updates Result list.
		updateResultLists(oldResultsList, newResultsList);

		// Updates Worksite
		updateWorksite(oldWorksite, newWorksite);

		// Updates the Systems.
		updateSystems(oldApogyEnvironment, newApogyEnvironment);

	}

	private void updateContext(Context oldContext, Context newContext) {
		ResultsList oldResultsList = null;
		ResultsList newResultsList = null;

		if (oldContext != null) {
			// Unregister from previous Context,
			oldContext.eAdapters().remove(getAdapter());

			// Gets old ResultsList.
			if (oldContext.getDataProductsList() != null) {
				oldResultsList = oldContext.getDataProductsList().getOperationCallResultsList();
			}
		}

		if (newContext != null) {
			// Register to new Context.
			newContext.eAdapters().add(getAdapter());

			// Gets new ResultsList.
			if (newContext.getDataProductsList() != null) {
				newResultsList = newContext.getDataProductsList().getOperationCallResultsList();
			}
		}

		// Updates Results.
		updateResultLists(oldResultsList, newResultsList);
	}

	private void updateSystems(ApogyEnvironment oldApogyEnvironment, ApogyEnvironment newApogyEnvironment) {
		getApogySystemAPIsNode().setApogyEnvironment(newApogyEnvironment);
	}

	private void updateResultLists(ResultsList oldResultsList, ResultsList newResultsList) {
		if (oldResultsList != null)
			oldResultsList.eAdapters().remove(getAdapter());

		if (newResultsList != null)
			newResultsList.eAdapters().add(getAdapter());

		// Updates the getResultsListNode ResultList.
		getResultsListNode().setResultsList(newResultsList);

	}

	private void updateWorksite(AbstractWorksite oldWorksite, AbstractWorksite newWorksite) {
		// Updates the WorksiteNode worksite if applicable.
		if (newWorksite instanceof Worksite) {
			Worksite worksite = (Worksite) newWorksite;
			setWorksiteNode(worksite.getWorksiteNode());
		} else {
			// Clears worksite.
			setWorksiteNode(null);
		}
	}

	protected Adapter getAdapter() {
		if (this.adapter == null) {
			this.adapter = new AdapterImpl() {
				@Override
				public void notifyChanged(Notification msg) {
					super.notifyChanged(msg);

					if (msg.getNotifier() instanceof ApogyEnvironment) {
						if (msg.getFeatureID(
								ApogyEnvironment.class) == ApogyCoreEnvironmentPackage.APOGY_ENVIRONMENT__ACTIVE_CONTEXT) {
							// Active Context has changed.
							Context oldContext = (Context) msg.getOldValue();
							Context newContext = (Context) msg.getOldValue();
							updateContext(oldContext, newContext);
						} else if (msg.getFeatureID(
								ApogyEnvironment.class) == ApogyCoreEnvironmentPackage.APOGY_ENVIRONMENT__ACTIVE_WORKSITE) {
							// Active Worksite has changed.
							AbstractWorksite oldWorksite = (AbstractWorksite) msg.getOldValue();
							AbstractWorksite newWorksite = (AbstractWorksite) msg.getNewValue();
							updateWorksite(oldWorksite, newWorksite);
						}
					} else if (msg.getNotifier() instanceof Context) {
						if (msg.getFeatureID(Context.class) == ApogyCoreInvocatorPackage.CONTEXT__DATA_PRODUCTS_LIST) {
							// ResultsList has changed.
							ResultsList oldResultsList = (ResultsList) msg.getOldValue();
							ResultsList newResultsList = (ResultsList) msg.getNewValue();
							updateResultLists(oldResultsList, newResultsList);
						}
					}
				}
			};
		}
		return this.adapter;
	}
} // DeploymentNodeImpl