plugins/ocl2ac/org.eclipse.emf.henshin.ocl2ac.gc2ac/src/org/eclipse/emf/henshin/ocl2ac/gc2ac/util/RuleClassifier.java

/**
 * <copyright>
 * OCL2AC is developed by Nebras Nassar based on an initial version developed by Thorsten Arendt and Jan Steffen Becker.
 * </copyright>
 */
package org.eclipse.emf.henshin.ocl2ac.gc2ac.util;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.henshin.model.Action;
import org.eclipse.emf.henshin.model.Attribute;
import org.eclipse.emf.henshin.model.Edge;
import org.eclipse.emf.henshin.model.Node;
import org.eclipse.emf.henshin.model.Rule;

/**
 * 
 * This class helps of identify the rules which aim for identifying the optimization cases. 
 *
 */
public class RuleClassifier {

	private Rule rule;
	public EList<Node> createActionNodes;
	public EList<Edge> createActionEdges;
	EList<Attribute> createActionAttributes;
	EList<Object> createActionElements = new BasicEList<Object>();

	public EList<Node> deleteActionNodes;
	EList<Edge> deleteActionEdges;
	EList<Attribute> deleteActionAttributes;
	EList<Object> deleteActionElements = new BasicEList<Object>();

	EList<Node> forbidActionNodes;
	EList<Edge> forbidActionEdges;
	EList<Attribute> forbidActionAttributes;
	EList<Object> forbidActionElements = new BasicEList<Object>();

	EList<Node> requireActionNodes;
	EList<Edge> requireActionEdges;
	EList<Attribute> requireActionAttributes;
	EList<Object> requireActionElements = new BasicEList<Object>();

	public EList<Node> preserveActionNodes;
	EList<Edge> preserveActionEdges;
	EList<Attribute> preserveActionAttributes;
	EList<Object> preserveActionElements = new BasicEList<Object>();

	public RuleClassifier(Rule rule) {
		this.rule = rule;
		createActionNodes = getActionNodes(Action.Type.CREATE);
		createActionEdges = getActionEdges(Action.Type.CREATE);
		createActionAttributes = getCreateActionAttributes();
		createActionElements.addAll(createActionNodes);
		createActionElements.addAll(createActionEdges);
		createActionElements.addAll(createActionAttributes);

		deleteActionNodes = getActionNodes(Action.Type.DELETE);
		deleteActionEdges = getActionEdges(Action.Type.DELETE);
		deleteActionAttributes = getDeleteActionAttributes();
		deleteActionElements.addAll(deleteActionNodes);
		deleteActionElements.addAll(deleteActionEdges);
		deleteActionElements.addAll(deleteActionAttributes);

		requireActionNodes = getActionNodes(Action.Type.REQUIRE);
		requireActionEdges = getActionEdges(Action.Type.REQUIRE);
		requireActionAttributes = getRequireActionAttributes();
		requireActionElements.addAll(requireActionNodes);
		requireActionElements.addAll(requireActionEdges);
		requireActionElements.addAll(requireActionAttributes);

		forbidActionNodes = getActionNodes(Action.Type.FORBID);
		forbidActionEdges = getActionEdges(Action.Type.FORBID);
		forbidActionAttributes = getForbidActionAttributes();
		forbidActionElements.addAll(forbidActionNodes);
		forbidActionElements.addAll(forbidActionEdges);
		forbidActionElements.addAll(forbidActionAttributes);

		preserveActionNodes = getActionNodes(Action.Type.PRESERVE);
		preserveActionEdges = getActionEdges(Action.Type.PRESERVE);
		preserveActionAttributes = getPreserveActionAttributes();
		preserveActionElements.addAll(preserveActionNodes);
		preserveActionElements.addAll(preserveActionEdges);
		preserveActionElements.addAll(preserveActionAttributes);
	}

	public int getRuleSize() {
		return createActionElements.size() + deleteActionElements.size() + requireActionElements.size()
				+ forbidActionElements.size() + preserveActionElements.size();
	}

	/**
	 * 
	 * @return
	 */
	public boolean doesRuleCreateOnly() {
		if (createActionElements != null) {
			if (deleteActionElements.size() == 0 && forbidActionElements.size() == 0
					&& requireActionElements.size() == 0)
				return true;
		}
		return false;
	}

	/**
	 * 
	 * @return
	 */
	public boolean doesRuleDeleteOnly() {
		if (deleteActionElements != null) {
			if (createActionElements.size() == 0 && forbidActionElements.size() == 0
					&& requireActionElements.size() == 0)
				return true;
		}
		return false;
	}

	/**
	 * 
	 * @param action
	 * @return
	 */
	private EList<Edge> getActionEdges(Action.Type action) {
		return rule.getActionEdges(new Action(action));
	}

	/**
	 * 
	 * @param action
	 * @return
	 */
	private EList<Node> getActionNodes(Action.Type action) {
		return rule.getActionNodes(new Action(action));
	}

	/**
	 * 
	 * @return
	 */
	private EList<Attribute> getCreateActionAttributes() {
		EList<Attribute> createActionAttributes = new BasicEList<Attribute>();
		for (Node node : rule.getRhs().getNodes()) {
			for (Attribute attr : node.getAttributes()) {
				if (attr.getAction() != null) {
					if (attr.getAction().getType() == Action.Type.CREATE)
						createActionAttributes.add(attr);
				}
			}
		}
		return createActionAttributes;
	}

	/**
	 * 
	 * @return
	 */
	private EList<Attribute> getDeleteActionAttributes() {
		EList<Attribute> deleteActionAttributes = new BasicEList<Attribute>();
		for (Node node : rule.getLhs().getNodes()) {
			for (Attribute attr : node.getAttributes()) {
				if (attr.getAction().getType() == Action.Type.DELETE)
					deleteActionAttributes.add(attr);
			}
		}
		return deleteActionAttributes;
	}

	/**
	 * 
	 * @return
	 */
	private EList<Attribute> getForbidActionAttributes() {
		EList<Attribute> forbidActionAttributes = new BasicEList<Attribute>();

		for (Node node : rule.getLhs().getNodes()) {
			for (Attribute attr : node.getAttributes()) {
				if (attr.getAction().getType() == Action.Type.FORBID)
					forbidActionAttributes.add(attr);
			}
		}
		return forbidActionAttributes;
	}

	/**
	 * 
	 * @return
	 */
	private EList<Attribute> getRequireActionAttributes() {
		EList<Attribute> requireActionAttributes = new BasicEList<Attribute>();

		for (Node node : rule.getLhs().getNodes()) {
			for (Attribute attr : node.getAttributes()) {
				if (attr.getAction().getType() == Action.Type.REQUIRE)
					requireActionAttributes.add(attr);
			}
		}
		return requireActionAttributes;
	}

	/**
	 * 
	 * @return
	 */
	private EList<Attribute> getPreserveActionAttributes() {
		EList<Attribute> preserveActionAttributes = new BasicEList<Attribute>();

		for (Node node : rule.getLhs().getNodes()) {
			for (Attribute attr : node.getAttributes()) {
				if (attr.getAction().getType() == Action.Type.PRESERVE)
					preserveActionAttributes.add(attr);
			}
		}
		return preserveActionAttributes;
	}

}