corba/src/share/classes/com/sun/corba/se/impl/orbutil/fsm/StateEngineImpl.java - edge/openjdk - Git at Google

 /*
  * Copyright (c) 2002, 2003, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.corba.se.impl.orbutil.fsm ;

 import java.util.HashMap ;
 import java.util.HashSet ;
 import java.util.Set ;
 import java.util.Iterator ;

 import org.omg.CORBA.INTERNAL ;

 import com.sun.corba.se.impl.orbutil.ORBUtility ;

 import com.sun.corba.se.spi.orbutil.fsm.Input ;
 import com.sun.corba.se.spi.orbutil.fsm.Guard ;
 import com.sun.corba.se.spi.orbutil.fsm.Action ;
 import com.sun.corba.se.spi.orbutil.fsm.ActionBase ;
 import com.sun.corba.se.spi.orbutil.fsm.State ;
 import com.sun.corba.se.spi.orbutil.fsm.StateEngine ;
 import com.sun.corba.se.spi.orbutil.fsm.StateImpl ;
 import com.sun.corba.se.spi.orbutil.fsm.FSM ;
 import com.sun.corba.se.spi.orbutil.fsm.FSMImpl ;

 import com.sun.corba.se.impl.orbutil.fsm.GuardedAction ;

 /**
  * Encodes the state transition function for a finite state machine.
  *
  * @author Ken Cavanaugh
  */
 public class StateEngineImpl implements StateEngine
 {
     // An action that does nothing at all.
     private static Action emptyAction = new ActionBase( "Empty" )
     {
         public void doIt( FSM fsm, Input in )
         {
         }
     } ;

     private boolean initializing ;
     private Action defaultAction ;

     public StateEngineImpl()
     {
         initializing = true ;
         defaultAction = new ActionBase("Invalid Transition")
             {
                 public void doIt( FSM fsm, Input in )
                 {
                     throw new INTERNAL(
                         "Invalid transition attempted from " +
                             fsm.getState() + " under " + in ) ;
                 }
             } ;
     }

     public StateEngine add( State oldState, Input input, Guard guard, Action action,
         State newState ) throws IllegalArgumentException,
         IllegalStateException
     {
         mustBeInitializing() ;

         StateImpl oldStateImpl = (StateImpl)oldState ;
         GuardedAction ga = new GuardedAction( guard, action, newState ) ;
         oldStateImpl.addGuardedAction( input, ga ) ;

         return this ;
     }

     public StateEngine add( State oldState, Input input, Action action,
         State newState ) throws IllegalArgumentException,
         IllegalStateException
     {
         mustBeInitializing() ;

         StateImpl oldStateImpl = (StateImpl)oldState ;
         GuardedAction ta = new GuardedAction( action, newState ) ;
         oldStateImpl.addGuardedAction( input, ta ) ;

         return this ;
     }

     public StateEngine setDefault( State oldState, Action action, State newState )
         throws IllegalArgumentException, IllegalStateException
     {
         mustBeInitializing() ;

         StateImpl oldStateImpl = (StateImpl)oldState ;
         oldStateImpl.setDefaultAction( action ) ;
         oldStateImpl.setDefaultNextState( newState ) ;

         return this ;
     }

     public StateEngine setDefault( State oldState, State newState )
         throws IllegalArgumentException, IllegalStateException
     {
         return setDefault( oldState, emptyAction, newState ) ;
     }

     public StateEngine setDefault( State oldState )
         throws IllegalArgumentException, IllegalStateException
     {
         return setDefault( oldState, oldState ) ;
     }

     public void done() throws IllegalStateException
     {
         mustBeInitializing() ;

         // optimize FSM here if desired.  For example,
         // we could choose different strategies for implementing
         // the state transition function based on the distribution
         // of values for states and input labels.

         initializing = false ;
     }

     public void setDefaultAction( Action act ) throws IllegalStateException
     {
         mustBeInitializing() ;
         defaultAction = act ;
     }

     public void doIt( FSM fsm, Input in, boolean debug )
     {
         // This method is present only for debugging.
         // innerDoIt does the actual transition.

         if (debug)
             ORBUtility.dprint( this, "doIt enter: currentState = " +
                 fsm.getState() + " in = " + in ) ;

         try {
             innerDoIt( fsm, in, debug ) ;
         } finally {
             if (debug)
                 ORBUtility.dprint( this, "doIt exit" ) ;
         }
     }

     private StateImpl getDefaultNextState( StateImpl currentState )
     {
         // Use the currentState defaults if
         // set, otherwise use the state engine default.
         StateImpl nextState = (StateImpl)currentState.getDefaultNextState() ;
         if (nextState == null)
             // The state engine default never changes the state
             nextState = currentState ;

         return nextState ;
     }

     private Action getDefaultAction( StateImpl currentState )
     {
         Action action = currentState.getDefaultAction() ;
         if (action == null)
             action = defaultAction ;

         return action ;
     }

     private void innerDoIt( FSM fsm, Input in, boolean debug )
     {
         if (debug) {
             ORBUtility.dprint( this, "Calling innerDoIt with input " + in ) ;
         }

         // Locals needed for performing the state transition, once we determine
         // the required transition.
         StateImpl currentState = null ;
         StateImpl nextState = null ;
         Action action = null ;

         // Do until no guard has deferred.
         boolean deferral = false ;
         do {
             deferral = false ; // clear this after each deferral!
             currentState = (StateImpl)fsm.getState() ;
             nextState = getDefaultNextState( currentState ) ;
             action = getDefaultAction( currentState ) ;

             if (debug) {
                 ORBUtility.dprint( this, "currentState      = " + currentState ) ;
                 ORBUtility.dprint( this, "in                = " + in ) ;
                 ORBUtility.dprint( this, "default nextState = " + nextState    ) ;
                 ORBUtility.dprint( this, "default action    = " + action ) ;
             }

             Set gas = currentState.getGuardedActions(in) ;
             if (gas != null) {
                 Iterator iter = gas.iterator() ;

                 // Search for a guard that is not DISABLED.
                 // All DISABLED means use defaults.
                 while (iter.hasNext()) {
                     GuardedAction ga = (GuardedAction)iter.next() ;
                     Guard.Result gr = ga.getGuard().evaluate( fsm, in ) ;
                     if (debug)
                         ORBUtility.dprint( this,
                             "doIt: evaluated " + ga + " with result " + gr ) ;

                     if (gr == Guard.Result.ENABLED) {
                         // ga has the next state and action.
                         nextState = (StateImpl)ga.getNextState() ;
                         action = ga.getAction() ;
                         if (debug) {
                             ORBUtility.dprint( this, "nextState = " + nextState ) ;
                             ORBUtility.dprint( this, "action    = " + action ) ;
                         }
                         break ;
                     } else if (gr == Guard.Result.DEFERED) {
                         deferral = true ;
                         break ;
                     }
                 }
             }
         } while (deferral) ;

         performStateTransition( fsm, in, nextState, action, debug ) ;
     }

     private void performStateTransition( FSM fsm, Input in,
         StateImpl nextState, Action action, boolean debug )
     {
         StateImpl currentState = (StateImpl)fsm.getState() ;

         // Perform the state transition.  Pre and post actions are only
         // performed if the state changes (see UML hidden transitions).

         boolean different = !currentState.equals( nextState ) ;

         if (different) {
             if (debug)
                 ORBUtility.dprint( this,
                     "doIt: executing postAction for state " + currentState ) ;
             try {
                 currentState.postAction( fsm ) ;
             } catch (Throwable thr) {
                 if (debug)
                     ORBUtility.dprint( this,
                         "doIt: postAction threw " + thr ) ;

                 if (thr instanceof ThreadDeath)
                     throw (ThreadDeath)thr ;
             }
         }

         try {
             // Note that action may be null in a transition, which simply
             // means that no action is needed.  Note that action.doIt may
             // throw an exception, in which case the exception is
             // propagated after making sure that the transition is properly
             // completed.
             if (action != null)
                 action.doIt( fsm, in ) ;
         } finally {
             if (different) {
                 if (debug)
                     ORBUtility.dprint( this,
                         "doIt: executing preAction for state " + nextState ) ;

                 try {
                     nextState.preAction( fsm ) ;
                 } catch (Throwable thr) {
                     if (debug)
                         ORBUtility.dprint( this,
                             "doIt: preAction threw " + thr ) ;

                     if (thr instanceof ThreadDeath)
                         throw (ThreadDeath)thr ;
                 }

                 ((FSMImpl)fsm).internalSetState( nextState ) ;
             }

             if (debug)
                 ORBUtility.dprint( this, "doIt: state is now " + nextState ) ;
         }
     }

     public FSM makeFSM( State startState ) throws IllegalStateException
     {
         mustNotBeInitializing() ;

         return new FSMImpl( this, startState ) ;
     }

     private void mustBeInitializing() throws IllegalStateException
     {
         if (!initializing)
             throw new IllegalStateException(
                 "Invalid method call after initialization completed" ) ;
     }

     private void mustNotBeInitializing() throws IllegalStateException
     {
         if (initializing)
             throw new IllegalStateException(
                 "Invalid method call before initialization completed" ) ;
     }
 }

 // end of StateEngineImpl.java
	/*
	* Copyright (c) 2002, 2003, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.corba.se.impl.orbutil.fsm ;

	import java.util.HashMap ;
	import java.util.HashSet ;
	import java.util.Set ;
	import java.util.Iterator ;

	import org.omg.CORBA.INTERNAL ;

	import com.sun.corba.se.impl.orbutil.ORBUtility ;

	import com.sun.corba.se.spi.orbutil.fsm.Input ;
	import com.sun.corba.se.spi.orbutil.fsm.Guard ;
	import com.sun.corba.se.spi.orbutil.fsm.Action ;
	import com.sun.corba.se.spi.orbutil.fsm.ActionBase ;
	import com.sun.corba.se.spi.orbutil.fsm.State ;
	import com.sun.corba.se.spi.orbutil.fsm.StateEngine ;
	import com.sun.corba.se.spi.orbutil.fsm.StateImpl ;
	import com.sun.corba.se.spi.orbutil.fsm.FSM ;
	import com.sun.corba.se.spi.orbutil.fsm.FSMImpl ;

	import com.sun.corba.se.impl.orbutil.fsm.GuardedAction ;

	/**
	* Encodes the state transition function for a finite state machine.
	*
	* @author Ken Cavanaugh
	*/
	public class StateEngineImpl implements StateEngine
	{
	// An action that does nothing at all.
	private static Action emptyAction = new ActionBase( "Empty" )
	{
	public void doIt( FSM fsm, Input in )
	{
	}
	} ;

	private boolean initializing ;
	private Action defaultAction ;

	public StateEngineImpl()
	{
	initializing = true ;
	defaultAction = new ActionBase("Invalid Transition")
	{
	public void doIt( FSM fsm, Input in )
	{
	throw new INTERNAL(
	"Invalid transition attempted from " +
	fsm.getState() + " under " + in ) ;
	}
	} ;
	}

	public StateEngine add( State oldState, Input input, Guard guard, Action action,
	State newState ) throws IllegalArgumentException,
	IllegalStateException
	{
	mustBeInitializing() ;

	StateImpl oldStateImpl = (StateImpl)oldState ;
	GuardedAction ga = new GuardedAction( guard, action, newState ) ;
	oldStateImpl.addGuardedAction( input, ga ) ;

	return this ;
	}

	public StateEngine add( State oldState, Input input, Action action,
	State newState ) throws IllegalArgumentException,
	IllegalStateException
	{
	mustBeInitializing() ;

	StateImpl oldStateImpl = (StateImpl)oldState ;
	GuardedAction ta = new GuardedAction( action, newState ) ;
	oldStateImpl.addGuardedAction( input, ta ) ;

	return this ;
	}

	public StateEngine setDefault( State oldState, Action action, State newState )
	throws IllegalArgumentException, IllegalStateException
	{
	mustBeInitializing() ;

	StateImpl oldStateImpl = (StateImpl)oldState ;
	oldStateImpl.setDefaultAction( action ) ;
	oldStateImpl.setDefaultNextState( newState ) ;

	return this ;
	}

	public StateEngine setDefault( State oldState, State newState )
	throws IllegalArgumentException, IllegalStateException
	{
	return setDefault( oldState, emptyAction, newState ) ;
	}

	public StateEngine setDefault( State oldState )
	throws IllegalArgumentException, IllegalStateException
	{
	return setDefault( oldState, oldState ) ;
	}

	public void done() throws IllegalStateException
	{
	mustBeInitializing() ;

	// optimize FSM here if desired. For example,
	// we could choose different strategies for implementing
	// the state transition function based on the distribution
	// of values for states and input labels.

	initializing = false ;
	}

	public void setDefaultAction( Action act ) throws IllegalStateException
	{
	mustBeInitializing() ;
	defaultAction = act ;
	}

	public void doIt( FSM fsm, Input in, boolean debug )
	{
	// This method is present only for debugging.
	// innerDoIt does the actual transition.

	if (debug)
	ORBUtility.dprint( this, "doIt enter: currentState = " +
	fsm.getState() + " in = " + in ) ;

	try {
	innerDoIt( fsm, in, debug ) ;
	} finally {
	if (debug)
	ORBUtility.dprint( this, "doIt exit" ) ;
	}
	}

	private StateImpl getDefaultNextState( StateImpl currentState )
	{
	// Use the currentState defaults if
	// set, otherwise use the state engine default.
	StateImpl nextState = (StateImpl)currentState.getDefaultNextState() ;
	if (nextState == null)
	// The state engine default never changes the state
	nextState = currentState ;

	return nextState ;
	}

	private Action getDefaultAction( StateImpl currentState )
	{
	Action action = currentState.getDefaultAction() ;
	if (action == null)
	action = defaultAction ;

	return action ;
	}

	private void innerDoIt( FSM fsm, Input in, boolean debug )
	{
	if (debug) {
	ORBUtility.dprint( this, "Calling innerDoIt with input " + in ) ;
	}

	// Locals needed for performing the state transition, once we determine
	// the required transition.
	StateImpl currentState = null ;
	StateImpl nextState = null ;
	Action action = null ;

	// Do until no guard has deferred.
	boolean deferral = false ;
	do {
	deferral = false ; // clear this after each deferral!
	currentState = (StateImpl)fsm.getState() ;
	nextState = getDefaultNextState( currentState ) ;
	action = getDefaultAction( currentState ) ;

	if (debug) {
	ORBUtility.dprint( this, "currentState = " + currentState ) ;
	ORBUtility.dprint( this, "in = " + in ) ;
	ORBUtility.dprint( this, "default nextState = " + nextState ) ;
	ORBUtility.dprint( this, "default action = " + action ) ;
	}

	Set gas = currentState.getGuardedActions(in) ;
	if (gas != null) {
	Iterator iter = gas.iterator() ;

	// Search for a guard that is not DISABLED.
	// All DISABLED means use defaults.
	while (iter.hasNext()) {
	GuardedAction ga = (GuardedAction)iter.next() ;
	Guard.Result gr = ga.getGuard().evaluate( fsm, in ) ;
	if (debug)
	ORBUtility.dprint( this,
	"doIt: evaluated " + ga + " with result " + gr ) ;

	if (gr == Guard.Result.ENABLED) {
	// ga has the next state and action.
	nextState = (StateImpl)ga.getNextState() ;
	action = ga.getAction() ;
	if (debug) {
	ORBUtility.dprint( this, "nextState = " + nextState ) ;
	ORBUtility.dprint( this, "action = " + action ) ;
	}
	break ;
	} else if (gr == Guard.Result.DEFERED) {
	deferral = true ;
	break ;
	}
	}
	}
	} while (deferral) ;

	performStateTransition( fsm, in, nextState, action, debug ) ;
	}

	private void performStateTransition( FSM fsm, Input in,
	StateImpl nextState, Action action, boolean debug )
	{
	StateImpl currentState = (StateImpl)fsm.getState() ;

	// Perform the state transition. Pre and post actions are only
	// performed if the state changes (see UML hidden transitions).

	boolean different = !currentState.equals( nextState ) ;

	if (different) {
	if (debug)
	ORBUtility.dprint( this,
	"doIt: executing postAction for state " + currentState ) ;
	try {
	currentState.postAction( fsm ) ;
	} catch (Throwable thr) {
	if (debug)
	ORBUtility.dprint( this,
	"doIt: postAction threw " + thr ) ;

	if (thr instanceof ThreadDeath)
	throw (ThreadDeath)thr ;
	}
	}

	try {
	// Note that action may be null in a transition, which simply
	// means that no action is needed. Note that action.doIt may
	// throw an exception, in which case the exception is
	// propagated after making sure that the transition is properly
	// completed.
	if (action != null)
	action.doIt( fsm, in ) ;
	} finally {
	if (different) {
	if (debug)
	ORBUtility.dprint( this,
	"doIt: executing preAction for state " + nextState ) ;

	try {
	nextState.preAction( fsm ) ;
	} catch (Throwable thr) {
	if (debug)
	ORBUtility.dprint( this,
	"doIt: preAction threw " + thr ) ;

	if (thr instanceof ThreadDeath)
	throw (ThreadDeath)thr ;
	}

	((FSMImpl)fsm).internalSetState( nextState ) ;
	}

	if (debug)
	ORBUtility.dprint( this, "doIt: state is now " + nextState ) ;
	}
	}

	public FSM makeFSM( State startState ) throws IllegalStateException
	{
	mustNotBeInitializing() ;

	return new FSMImpl( this, startState ) ;
	}

	private void mustBeInitializing() throws IllegalStateException
	{
	if (!initializing)
	throw new IllegalStateException(
	"Invalid method call after initialization completed" ) ;
	}

	private void mustNotBeInitializing() throws IllegalStateException
	{
	if (initializing)
	throw new IllegalStateException(
	"Invalid method call before initialization completed" ) ;
	}
	}

	// end of StateEngineImpl.java