View Javadoc
   package org.smartcomps.twister.engine.priv.core.dynamic.impl;
   
   import org.smartcomps.twister.engine.priv.core.definition.impl.ActivityImpl;
   import org.smartcomps.twister.engine.priv.core.definition.Activity;
   import org.smartcomps.twister.engine.priv.core.dynamic.*;
   import org.smartcomps.twister.engine.priv.core.dynamic.impl.xao.VariableXAO;
   import org.smartcomps.twister.engine.exception.ProcessStructuralException;
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
  
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Set;
  
  /***
   * Please put some JavaDoc here.
   */
  public abstract class ExecutionContextImpl implements ExecutionContext, Comparable {
  
      private VariableXAO variableXAO = null;
  	private ExecutionContextFactory ecFactory = null;
  	protected static Log log = LogFactory.getLog(ExecutionContextImpl.class);
  
  	private Long id;
  	private int status;
  	private StructuredEC container;
      private Set processInstance = new HashSet();
  	private Collection events = new HashSet();
  
  //  This is a purely technical field to indicate the position of the context within
  //  its container. It should be managed by Hibernate in the future but right now
  //  there's no other choice than this.
  	private int index;
  
  	public Long getId() {
  		return id;
  	}
  
  	public void setId(Long id) {
  		this.id = id;
  	}
  
  	public int getStatus() {
  		return status;
  	}
  
  	public void setStatus(int status) {
  		this.status = status;
  	}
  
  	public StructuredEC getContainer() {
  		return container;
  	}
  
  	public void setContainer(StructuredEC container) {
  		this.container = container;
  	}
  
  	public Collection getEvents() {
  		return events;
  	}
  
  	public void setEvents(Collection events) {
  		this.events = events;
  	}
  
      public void addEvent(ExecutionEvent event) {
          this.events.add(event);
      }
  
      public ProcessInstance getInstance() {
          if (processInstance == null || processInstance.size() == 0) return null;
          return (ProcessInstance) processInstance.iterator().next();
      }
  
      public void setInstance(ProcessInstance instance) {
          HashSet instSet = new HashSet(1);
          instSet.add(instance);
          this.processInstance = instSet;
      }
  
      /***
       * TECHNICAL, DO NOT USE
       */
      protected Set getProcessInstance() {
          return processInstance;
      }
  
      /***
       * TECHNICAL, DO NOT USE
       */
      protected void setProcessInstance(Set processInstance) {
          this.processInstance = processInstance;
      }
  
  	/***
  	 * TECHNICAL, DO NOT USE
  	 */
  	public int getIndex() {
 		return index;
 	}
 
 	/***
 	 * TECHNICAL, DO NOT USE
 	 */
 	public void setIndex(int index) {
 		this.index = index;
 	}
 
 	/***
 	 * Gets this execution context initial activity (the one whose execution
 	 * resulted in the creation of this execution context) passing through
 	 * its parent container or process instance.
 	 * @return Activity
 	 */
 	protected Activity getInitialActivity() {
 		Activity result = null;
 		if (this.getContainer() != null) {
 			result = this.getContainer().getActivityForChildContext(this);
 		} else if (this.getInstance() != null) {
 			result = this.getInstance().getProcess().getActivity();
 		} else {
 			throw new ProcessStructuralException("An activity doesn't have any container nor " +
 					"process instance : " + this);
 		}
 		return result;
 	}
 
     public ProcessInstance fetchInstance() {
         if (this.getInstance() != null) {
             return getInstance();
         } else {
             StructuredEC container = getContainer();
             while (container.getInstance() == null) container = container.getContainer();
             return container.getInstance();
         }        
     }
 
 	protected void notifyExecutionToContainer() {
 		if (this.getContainer() != null) {
 			this.getContainer().notifyExecution(this);
 		} else if (this.getInstance() != null) {
 			this.getInstance().notifyExecution(this);
 		} else {
 			throw new ProcessStructuralException("An activity doesn't have any container nor " +
 					"process instance : " + this);
 		}
 	}
 
 	protected void notifyTerminationToContainer() {
 		if (this.getContainer() != null) {
 			this.getContainer().notifyTermination(this);
 		} else if (this.getInstance() != null) {
 			this.getInstance().notifyTermination(this);
 		} else {
 			throw new ProcessStructuralException("An activity doesn't have any container nor " +
 					"process instance : " + this);
 		}
 	}
 
     protected void completeChildren(StructuredEC ec) {
         for (int m = 0; m < ec.getExecutionContexts().size(); m++) {
             ExecutionContext childContext = (ExecutionContext) ec.getExecutionContexts().get(m);
             if (childContext.getStatus() == ExecutionContext.ACTIVE) {
                 childContext.setStatus(ExecutionContext.COMPLETED);
                 if (childContext instanceof StructuredEC) {
                     completeChildren((StructuredEC)childContext);
                 }
             }
         }
     }
 
 	protected ExecutionContextFactory getExecutionContextFactory() {
 		if (ecFactory == null) {
 			ecFactory = new ExecutionContextFactory();
 		}
 		return ecFactory;
 	}
 
     protected VariableXAO getVariableXAO() {
         if (variableXAO == null) {
             variableXAO = new VariableXAO();
         }
         return variableXAO;
     }
 
 	public int compareTo(Object o) {
 		if (o instanceof ExecutionContextImpl) {
 			if (((ExecutionContextImpl)o).getIndex() > this.getIndex()) return -1;
 			else if (((ExecutionContextImpl)o).getIndex() == this.getIndex()) return 0;
 			else return 1;
 		}
 		return 0;
 	}
 
 }