-package org.argeo.slc.client.ui.views;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.SortedMap;
-import java.util.TreeMap;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.argeo.eclipse.ui.TreeObject;
-import org.argeo.eclipse.ui.TreeParent;
-import org.argeo.slc.SlcException;
-import org.argeo.slc.execution.ExecutionFlowDescriptor;
-import org.argeo.slc.execution.ExecutionModuleDescriptor;
-import org.argeo.slc.runtime.SlcAgent;
-import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.Viewer;
-
-public class ExecutionModulesContentProvider implements ITreeContentProvider {
- private final static Log log = LogFactory
- .getLog(ExecutionModulesContentProvider.class);
-
- private List<SlcAgent> slcAgents;
-
- public Object[] getChildren(Object parent) {
-
- if (parent instanceof ExecutionModuleNode) {
- ExecutionModuleNode executionModuleNode = (ExecutionModuleNode) parent;
- ExecutionModuleDescriptor emd = executionModuleNode.getDescriptor();
-
- // Terminate the building of UI specific object emd
- emd = executionModuleNode
- .getAgentNode()
- .getAgent()
- .getExecutionModuleDescriptor(emd.getName(),
- emd.getVersion());
- executionModuleNode.cacheDescriptor(emd);
-
- // This is not recursive, e.g. ExecutionModuleNode build a Tree of
- // specific
- // treeObject and cache it in the cacheDescriptor.
- // Then we only have TreeObjects
- return executionModuleNode.getChildren();
- } else if (parent instanceof AgentNode) {
- AgentNode agentNode = (AgentNode) parent;
-
- if (log.isTraceEnabled())
- log.trace("Scan agent " + agentNode);
-
- agentNode.clearChildren();
- for (ExecutionModuleDescriptor desc : agentNode.getAgent()
- .listExecutionModuleDescriptors()) {
- agentNode.addChild(new ExecutionModuleNode(agentNode, desc));
- }
-
- return agentNode.getChildren();
- } else if (parent instanceof TreeParent) {
- return ((TreeParent) parent).getChildren();
- } else if (parent instanceof FlowNode) {
- return new Object[0];
- } else {
- List<AgentNode> agentNodes = new ArrayList<AgentNode>();
- for (SlcAgent slcAgent : slcAgents) {
- agentNodes.add(new AgentNode(slcAgent));
- }
- return agentNodes.toArray();
- }
- }
-
- public Object getParent(Object node) {
- // if (node instanceof TreeObject) {
- // return ((TreeObject) node).getParent();
- // }
- return null;
- }
-
- public boolean hasChildren(Object parent) {
- if (parent instanceof TreeParent && ((TreeParent) parent).isLoaded()) {
- return ((TreeParent) parent).hasChildren();
- } else if (parent instanceof AgentNode) {
- return true;
- } else if (parent instanceof ExecutionModuleNode) {
- return true;
- }
- return false;
- }
-
- public void inputChanged(Viewer v, Object oldInput, Object newInput) {
- }
-
- public void dispose() {
- }
-
- public Object[] getElements(Object parent) {
- return getChildren(parent);
- }
-
- public void setSlcAgents(List<SlcAgent> slcAgents) {
- this.slcAgents = slcAgents// for (String flowName :
- // executionModuleNode.getFlowDescriptors()
- // .keySet()) {
- // executionModuleNode.addChild(new FlowNode(flowName,
- // executionModuleNode));
- // }
- ;
- }
-
- public class AgentNode extends TreeParent {
- private final SlcAgent agent;
-
- public AgentNode(SlcAgent agent) {
- super(agent.toString());
- this.agent = agent;
- }
-
- public SlcAgent getAgent() {
- return agent;
- }
- }
-
- public class ExecutionModuleNode extends TreeParent {
- private final AgentNode agentNode;
- private ExecutionModuleDescriptor descriptor;
- private Map<String, ExecutionFlowDescriptor> flowDescriptors;
-
- public ExecutionModuleNode(AgentNode agentNode,
- ExecutionModuleDescriptor descriptor) {
- super(descriptor.toString());
- this.agentNode = agentNode;
- this.descriptor = descriptor;
-
- }
-
- public AgentNode getAgentNode() {
- return agentNode;
- }
-
- public ExecutionModuleDescriptor getDescriptor() {
- return descriptor;
- }
-
- public void cacheDescriptor(ExecutionModuleDescriptor descriptor) {
- this.descriptor = descriptor;
-
- SortedMap<String, FolderNode> folderNodes = new TreeMap<String, FolderNode>();
-
- flowDescriptors = new HashMap<String, ExecutionFlowDescriptor>();
- for (ExecutionFlowDescriptor fd : descriptor.getExecutionFlows()) {
- if (log.isTraceEnabled())
- log.trace("fd.path=" + fd.getPath() + ", fd.name="
- + fd.getName());
- Map<String, Object> values = fd.getValues();
-
- if (values == null)
- log.debug("No attribute for " + fd.getName());
- else
- for (String key : values.keySet())
- log.debug(key + " - " + values.get(key));
-
- // find path and label
- String path;
- String label;
- int lastSlash = fd.getName().lastIndexOf('/');
- if ((fd.getPath() == null || fd.getPath().trim().equals(""))
- && lastSlash >= 0) {
- path = fd.getName().substring(0, lastSlash);
- label = fd.getName().substring(lastSlash + 1);
- } else {
- path = fd.getPath();
- label = fd.getName();
- }
- // if (log.isTraceEnabled())
- // log.trace("path=" + path + ", label=" + label);
-
- if (path == null || path.trim().equals("")
- || path.trim().equals("/")) {
- // directChildren.put(name, new FlowNode(name, this));
- addChild(new FlowNode(label, fd.getName(), fd.getValues(),
- this));
- } else {
- FolderNode folderNode = mkdirs(this, path, folderNodes);
- // TODO : why do we add a reference to the parent ?
- // Probably to differentiate 2 flow nodes with same name but
- // distinct execution Node. TBC
- folderNode.addChild(new FlowNode(label, fd.getName(), fd
- .getValues(), this));
-
- }
-
- flowDescriptors.put(fd.getName(), fd);
- }
- // TODO: make it readonly
- }
-
- protected FolderNode mkdirs(TreeParent root, String path,
- SortedMap<String, FolderNode> folderNodes) {
- // Normalize
- if (path.charAt(0) != '/')
- path = '/' + path;
- if (path.charAt(path.length() - 1) == '/')
- path = path.substring(0, path.length() - 1);
-
- if (folderNodes.containsKey(path))
- return folderNodes.get(path);
-
- int lastIndx = path.lastIndexOf('/');
- String folderName;
- String parentPath;
- if (lastIndx >= 0) {
- folderName = path.substring(lastIndx + 1);
- parentPath = path.substring(0, lastIndx);
- } else {
- folderName = path;
- parentPath = "";
- }
-
- TreeParent parent;
- if (parentPath.equals(""))
- parent = root;
- else
- parent = mkdirs(root, parentPath, folderNodes);
- FolderNode newFolder = new FolderNode(folderName);
- parent.addChild(newFolder);
- folderNodes.put(path, newFolder);
- return newFolder;
- }
-
- public Map<String, ExecutionFlowDescriptor> getFlowDescriptors() {
- return flowDescriptors;
- }
-
- }
-
- public class FlowNode extends TreeObject {
- private final String flowName;
- private final ExecutionModuleNode executionModuleNode;
-
- // TODO : handle casting from various object type to String and reverse.
- private final Map<String, Object> values;
-
- public FlowNode(String label, String flowName,
- Map<String, Object> values, ExecutionModuleNode parent) {
- super(label);
- this.flowName = flowName;
- this.values = values;
- this.executionModuleNode = parent;
- }
-
- public Map<String, Object> getValues() {
- return values;
- }
-
- public Object getValueByKey(String key) {
- return values.get(key);
- }
-
- public void setValueByKey(String key, Object value) {
- if (values.get(key) == null)
- throw new SlcException("Unsupported Parameter " + key
- + " for FlowNode " + flowName);
- else {
- values.remove(key);
- values.put(key, value);
- }
- }
-
- public String getFlowName() {
- return flowName;
- }
-
- public ExecutionModuleNode getExecutionModuleNode() {
- return executionModuleNode;
- }
-
- }
-
- public class FolderNode extends TreeParent {
- public FolderNode(String name) {
- super(name);
- }
-
- }
-}