/*
* 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