ViewContentProvider.java

/*
 * #%~
 * Combinatorial Testing
 * %%
 * Copyright (C) 2008 - 2014 Overture
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/gpl-3.0.html>.
 * #~%
 */
package org.overture.ide.plugins.combinatorialtesting.views;

import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.part.ViewPart;
import org.overture.ast.analysis.AnalysisAdaptor;
import org.overture.ast.analysis.AnalysisException;
import org.overture.ast.definitions.ANamedTraceDefinition;
import org.overture.ast.definitions.PDefinition;
import org.overture.ast.definitions.SClassDefinition;
import org.overture.ast.modules.AModuleModules;
import org.overture.ast.node.INode;
import org.overture.ct.utils.TraceHelperNotInitializedException;
import org.overture.ide.core.resources.IVdmProject;
import org.overture.ide.plugins.combinatorialtesting.views.treeView.ITreeNode;
import org.overture.ide.plugins.combinatorialtesting.views.treeView.NotYetReadyTreeNode;
import org.overture.ide.plugins.combinatorialtesting.views.treeView.ProjectTreeNode;
import org.overture.ide.plugins.combinatorialtesting.views.treeView.TraceTreeNode;
import org.overture.ide.plugins.combinatorialtesting.views.treeView.TreeParent;
import org.xml.sax.SAXException;

public class ViewContentProvider implements IStructuredContentProvider,
		ITreeContentProvider
{
	private TreeParent invisibleRoot;
	ViewPart viewer;
	Map<INode, List<TraceTreeNode>> containerNodes = new HashMap<INode, List<TraceTreeNode>>();

	public ViewContentProvider(ViewPart p)
	{
		// this.traceHelpers = trs;
		viewer = p;
	}

	public void inputChanged(Viewer v, Object oldInput, Object newInput)
	{

	}

	public void resetCache(IVdmProject project)
	{
		Set<INode> containers = TraceAstUtility.getTraceContainers(project);
		for (INode iNode : containers)
		{
			containerNodes.remove(iNode);
		}
	}

	public void dispose()
	{
	}

	public void addChild(ProjectTreeNode project)
	{
		invisibleRoot.addChild(project);
	}

	public Object[] getElements(Object parent)
	{
		if (invisibleRoot == null)
		{
			initialize();
		}
		return getChildren(invisibleRoot);
	}

	public Object getParent(Object child)
	{
		if (child instanceof ITreeNode)
		{
			return ((ITreeNode) child).getParent();
		}
		return null;
	}

	public Object[] getChildren(Object parent)
	{
		if (parent instanceof ProjectTreeNode)
		{
			Set<INode> containers = TraceAstUtility.getTraceContainers(((ProjectTreeNode) parent).project);
			return containers.toArray();
		}
		if (parent instanceof ITreeNode)
		{
			return ((ITreeNode) parent).getChildren().toArray();
		}
		if (parent instanceof SClassDefinition
				|| parent instanceof AModuleModules)
		{
			List<TraceTreeNode> children = new Vector<TraceTreeNode>();

			List<ANamedTraceDefinition> traceDefs = TraceAstUtility.getTraceDefinitions((INode) parent);
			if (containerNodes.containsKey(parent)
					&& containerNodes.get(parent).size() == traceDefs.size())
			{
				return containerNodes.get(parent).toArray();
			} else
			{

				for (ANamedTraceDefinition def : traceDefs)
				{
					// ITracesHelper tr = traceHelpers.get(TraceAstUtility.getProject(def));
					try
					{
						children.add(new TraceTreeNode(def));
					} catch (SAXException e)
					{
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IOException e)
					{
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (ClassNotFoundException e)
					{
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (TraceHelperNotInitializedException e)
					{
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				containerNodes.put((INode) parent, children);
			}

			return children.toArray();
		}

		return new Object[0];
	}

	public boolean hasChildren(Object parent)
	{
		if (parent instanceof ProjectTreeNode)
		{
			HasTraceAnalysis analysis = new HasTraceAnalysis();
			for (INode node : ((ProjectTreeNode) parent).project.getModel().getRootElementList())
			{
				if (analysis.hasTrace(node))
				{
					return true;
				}

			}
			return false;

		} else if (parent instanceof NotYetReadyTreeNode)
		{
			return false;
		}
		if (parent instanceof ITreeNode)
		{
			return ((ITreeNode) parent).hasChildren();
		} else if (parent instanceof SClassDefinition
				|| parent instanceof AModuleModules)
		{
			return true;
		}
		return false;
	}

	static class HasTraceAnalysis extends AnalysisAdaptor
	{
		boolean hasTrace = false;

		public boolean hasTrace(INode node)
		{
			hasTrace = false;

			try
			{
				node.apply(this);
			} catch (Throwable e)
			{
			}

			return hasTrace;
		}

		@Override
		public void defaultSClassDefinition(SClassDefinition node)
				throws AnalysisException
		{
			for (PDefinition def : node.getDefinitions())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					hasTrace = true;
					throw new AnalysisException("stop search");
				}
			}
		}

		@Override
		public void caseAModuleModules(AModuleModules node)
				throws AnalysisException
		{
			for (PDefinition def : node.getDefs())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					hasTrace = true;
					throw new AnalysisException("stop search");
				}
			}
		}

	}

	static class TraceContainerSearch extends AnalysisAdaptor
	{
		Set<INode> containers = new HashSet<INode>();

		public Set<INode> getTraceContainers(INode node)
		{
			containers.clear();

			try
			{
				node.apply(this);
			} catch (Throwable e)
			{

			}

			return containers;
		}

		@Override
		public void defaultSClassDefinition(SClassDefinition node)
				throws AnalysisException
		{
			for (PDefinition def : node.getDefinitions())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					containers.add(node);
					throw new AnalysisException("stop search");
				}
			}
		}

		@Override
		public void caseAModuleModules(AModuleModules node)
				throws AnalysisException
		{
			for (PDefinition def : node.getDefs())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					containers.add(node);
					throw new AnalysisException("stop search");
				}
			}
		}

	}

	static class TraceSearch extends AnalysisAdaptor
	{
		List<ANamedTraceDefinition> containers = new Vector<ANamedTraceDefinition>();

		public List<ANamedTraceDefinition> getTraces(INode node)
		{
			containers.clear();

			try
			{
				node.apply(this);
			} catch (Throwable e)
			{

			}

			return containers;
		}

		@Override
		public void defaultSClassDefinition(SClassDefinition node)
		{
			for (PDefinition def : node.getDefinitions())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					containers.add((ANamedTraceDefinition) def);
				}
			}
		}

		@Override
		public void caseAModuleModules(AModuleModules node)
		{
			for (PDefinition def : node.getDefs())
			{
				if (def instanceof ANamedTraceDefinition)
				{
					containers.add((ANamedTraceDefinition) def);
				}
			}
		}

	}

	/*
	 * We will set up a dummy model to initialize tree heararchy. In a real code, you will connect to a real model and
	 * expose its hierarchy.
	 */
	private void initialize()
	{
		invisibleRoot = new TreeParent("");

		ProjectTreeNode projectTreeNode;

		for (IVdmProject project : TraceAstUtility.getProjects())
		{
			HasTraceAnalysis analysis = new HasTraceAnalysis();
			for (INode node : project.getModel().getRootElementList())
			{
				if (analysis.hasTrace(node))
				{
					projectTreeNode = new ProjectTreeNode(project);
					invisibleRoot.addChild(projectTreeNode);
					break;
				}
			}
		}

	}
}