alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (StateEngineImpl.java)

This example Java source code file (StateEngineImpl.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

action, actionbase, corba, fsm, guardedaction, illegalargumentexception, illegalstateexception, input, invalid, state, stateengine, stateengineimpl, stateimpl, threaddeath, throwable, util

The StateEngineImpl.java Java example source code

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

Other Java examples (source code examples)

Here is a short list of links related to this Java StateEngineImpl.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.