org.ow2.bonita.pvm.model.Node Maven / Gradle / Ivy

Go to download
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.ow2.bonita.pvm.model;

import java.util.List;
import java.util.Map;

import org.ow2.bonita.pvm.Execution;

/**
 * a node in a {@link OpenProcessDefinition} graph.
 * 
 * 
 * The node supports both graph based process models as well as block structured
 * (tree based) process models. First we describe tranisions that can be used to
 * form graph based process structures and then we'll describe node composition
 * to form block structured process models. Both models can be combined as well.
 * 
 * 
 * 
 * Nodes have {@link #getIncomingTransitions() incoming} and
 * {@link #getOutgoingTransitions() outgoing transitions}. These are lists of
 * transitions.
 * 
 * 
 * 
 * Optionally, transitions can have names. In that case the transition
 * {@link #getOutgoingTransition(String) names are associated to node's outgoing
 * transitions}. The {@link #getOutgoingTransitionsMap() map of outgoing
 * transitions} provides easy access to the named transitions.
 * 
 * 
 * 
 * One of the outgoing transitions can optionally be marked as
 * {@link #getDefaultTransition() the default transition}.
 * 
 * 
 * 
 * Block structured process languages have composite nodes that can be modeled
 * with the {@link #getParent() parent}-{@link #getNodes() child} relation.
 * 
 * 
 * @author Tom Baeyens
 */
public interface Node extends CompositeElement {

  /**
   * the list of outgoing transitions. Caution: the actual member is returned.
   * No copy is made.
   */
  List getOutgoingTransitions();

  /** the default outgoing transition. */
  Transition getDefaultTransition();

  /**
   * the first leaving transition with the given name or null of no such leaving
   * transition exists. If the multiple transitions have the given transition
   * name, the first (in order of {@link #getOutgoingTransitions()}) will be
   * returned.
   * 
   * @param transitionName
   *          is the name of the transition to take. A null value will match the
   *          first unnamed transition.
   */
  Transition getOutgoingTransition(String transitionName);

  /**
   * indicates if a leaving transition with the given transitionName exists. A
   * null value matches an unnamed transition.
   */
  boolean hasOutgoingTransition(String transitionName);

  /** indicates if this node has leaving transitions */
  boolean hasOutgoingTransitions();

  /**
   * the leaving transitions, keyed by transition name. If a transition with the
   * same name occurs mutltiple times, the first one is returned. Leaving
   * transitions with a null value for their name are not included in the map.
   * Beware: the actual member is returned. No copy is made. In fact, the
   * returned map is maintained as a cache. So updates to the map will influence
   * subsequent retrievals of outgoing transitions by name.
   */
  Map getOutgoingTransitionsMap();

  /**
   * searches for the given transitionName in this node and then up the parent
   * chain. Returns null if no such transition is found.
   */
  Transition findOutgoingTransition(String transitionName);

  /**
   * the list of arriving transitions. Beware: the actual member is returned. No
   * copy is made.
   */
  List getIncomingTransitions();

  /** indicates if this node has arriving transitions */
  boolean hasIncomingTransitions();

  /**
   * retrieve the parent node in the composite node structure. This is different
   * from {@link ObservableElement#getParent()} in that it is restricted to the
   * parent nodes. It doesn't take into account the process definition.
   */
  Node getParentNode();

  /**
   * indicates if this node should be executed asynchronously.
   */
  boolean isExecutionAsync();

  /**
   * indicates if signals should be processed asynchronously.
   */
  boolean isSignalAsync();

  /**
   * indicates if execution should proceed asynchronously
   * when this node is left over any of the outgoing transitions.
   */
  boolean isLeaveAsync();

  /**
   * indicates if this node behaviour needs to know
   * {@link Execution#getPreviousNode() the previous node} or
   * {@link Execution#getPreviousTransition() previous transition}. If this
   * property is set to true, the properties {@link Execution#getPreviousNode()}
   * and {@link Execution#getPreviousTransition()} will be available to the node
   * behaviour when it is executed or signalled.
   */
  boolean isPreviousNeeded();
}