source: trunk/org/expeditee/agents/DefaultAgent.java@ 4

package org.expeditee.agents;

import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameGraphics;
import org.expeditee.stats.SessionStats;

/**
 * The framework for loading of agents accounts for two possible constructors.
 * The first takes no parametres and is called when the agent is run without
 * parametres. The second takes a single string parametre which is the
 * constructor called when an agent is run with a parametre.
 * 
 * @author johnathon
 * 
 */
public abstract class DefaultAgent implements Agent {

        protected Frame _start = null;

        protected Frame _end = null;

        protected boolean _running = true;

        protected boolean _stop = false;

        /**
         * Performs any pre-processing of the starting frame, which may include
         * searching the Frame for tags that determine the Agent behaviour
         * 
         * @param start
         */
        public boolean initialise(Frame init) {
                return true;
        }

        public void setStartFrame(Frame start) {
                _start = start;
        }

        public void run() {
                // init is now called by Actions.java
                /*
                 * if(!initialise(_start)){ FrameGraphics.ErrorMessage("Error
                 * initialising agent."); _running = false; return; }
                 */

                SessionStats.setEnabled(false);

                _end = process(_start);

                finalise(_start);

                _running = false;

                SessionStats.setEnabled(true);
        }

        public boolean hasResultFrame() {
                return _end != null;
        }

        public Frame getResultFrame() {
                return _end;
        }

        /**
         * Processes the given Frame, behaviour depends on individual
         * implementation. If this JAG displays any kind of completion Frame to the
         * user it should be returned from this method, otherwise null can be
         * returned.
         * 
         * @param frame
         *            the Frame to process
         * @return The completion Frame to show to the user, or null
         */
        protected abstract Frame process(Frame frame);

        /**
         * Performs any post-processing actions, such as displaying a completion
         * message to the user
         * 
         * @param frame
         *            The starting Frame this Agent was executed on
         */
        protected abstract void finalise(Frame frame);

        /**
         * Displays a message to the user
         * 
         * @param message
         *            The message to display to the user
         */
        protected void message(String message) {
                FrameGraphics.DisplayMessageAlways(message);
        }

        protected void overwriteMessage(String message) {
                FrameGraphics.OverwriteMessage(message);
        }

        public boolean isRunning() {
                return _running;
        }

        public void stop() {
                _stop = true;
        }

        public void interrupt() {
                stop();
        }
}