root/simulator/trunk/src/simulator/system.h

//    OSRail -- a network enabled railroad operations simulator and utilities
//    Copyright (C) 2007,2008 Samuel E. Henley sehenley@comcast.net
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program 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 for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//
// Build System
#ifndef SYSTEM_H
#define SYSTEM_H
/// \file
/// Header file for System interface

#ifndef WIN32
     #include <signal.h>
#endif //WIN32

/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup system "System"
    /// @{

/// System is the simulation main loop.
/// This is an implementation of the ISystem abstract class
class System : public ISystem
{
public:
    /// Simulation state mechine.
    /// States my be added - insure that
    /// there is a one to one mapping of the
    /// dispatch_table and the initialization
    /// code in  System::startup.
    enum eSystemState
    {
        NONE = 0,
        STARTUP,
        GUI,
        ROUTESTARTUP,
        ROUTESHUTDOWN,
        SIMULATION,
        SHUTDOWN
    };

//  typedef void (System::*SystemDispatchFunction)();
    virtual IAi*              getAiInterface() { return static_cast<IAi*>( ai.get() );}
    virtual IConsoleClient*   getConsoleClientInterface() { return static_cast<IConsoleClient*>( console.get());}
    virtual IFactory*         getFactoryInterface() { return static_cast<IFactory*>( factory.get());}
    virtual IGraphics*        getGraphicsInterface() { return static_cast<IGraphics*>( graphics.get());}
    virtual IGui*             getGuiInterface() { return static_cast<IGui*>( gui.get());}
    virtual IInput*           getInputInterface() { return static_cast<IInput*>( input.get());}
    virtual INetwork*         getNetworkInterface() { return static_cast<INetwork*>( network.get());}
    virtual IPropertyManager* getPropertyManagerInterface() { return static_cast<IPropertyManager*>( propertymanager.get());}
    virtual ISimulation*      getSimulationInterface() { return static_cast<ISimulation*>( simulation.get());}
    virtual ISound*           getSoundInterface() { return static_cast<ISound*>( sound.get());}
    virtual ISystem*          getSystemInterface() { return this;}
    virtual ITask*            getTaskInterface() { return static_cast<ITask*>( task.get());}
    virtual ITest*            getTestInterface() { return static_cast<ITest*>( test.get());}

    /// Get time from last render
    /// \return milliseconds from last graphics render
    virtual unsigned long           getFrameMilliseconds() { return getGraphicsInterface()->getFrameMilliseconds(); }

private:
        /// \addtogroup systemstate "System State Machine"
        /// @{
    class SystemState
    {
    public:
        /// Initialize the state.
        /// \param system Simulator interface.
        virtual void startup( System& system ) = 0;
        /// Uninitialize the state.
        /// \param system Simulator interface.
        virtual void shutdown( System& system ) = 0;
        /// Background frame processing for the state.
        /// \param system Simulator interface.
        virtual void background( System& system ) = 0;
        /// Foreground processing for the state, maybe foreground or background
        /// \param system Simulator interface.
        virtual void operator()( System& system ) = 0;
    };

    template<int T>
    class State : public SystemState
    {
        /// Initialize the state.
        /// \param system Simulator interface.
        virtual void startup( System& system );
        /// Uninitialize the state.
        /// \param system Simulator interface.
        virtual void shutdown( System& system );
        /// Background frame processing for the state.
        /// \param system Simulator interface.
        virtual void background( System& system );
        /// Foreground processing for the state, maybe foreground or background
        /// \param system Simulator interface.
        virtual void operator()( System& system );
    };

    typedef class State<STARTUP>        StartupState;
    typedef class State<GUI>            GuiState;
    typedef class State<ROUTESTARTUP>   RouteStartupState;
    typedef class State<ROUTESHUTDOWN>  RouteShutdownState;
    typedef class State<SIMULATION>     SimulationState;
    typedef class State<SHUTDOWN>       ShutdownState;

    std::vector< boost::shared_ptr<SystemState> > states;
        /// @}   group systemstate
public:
    System();
    virtual ~System();



    // ISimulatorComponent interfaces
    /// Initialize the simulator.
    virtual void  startup();    // Initialize
    /// Per frame call
    virtual void  operator()(); // ISystem Frame
    /// Shudown the simulator.
    virtual void  shutdown();   // Shutdown
    /// Set the options from the cammandline.
    /// \param map - command line options from boost library.
    virtual void  setOptions( const boost::program_options::variables_map& map );

    /// Simulator is running (any state, and a window).
    /// \return true=running
    virtual bool running() const;

    /// Simulator is in any state.
    /// \return true=any state
    virtual bool anyState() const;


private:
//  std::vector<SystemDispatchFunction> dispatch_table;

    /// Use base class to reduce coupling
    boost::shared_ptr<ISimulatorComponent> ai;
    boost::shared_ptr<ISimulatorComponent> console;
    boost::shared_ptr<ISimulatorComponent> factory;
    boost::shared_ptr<ISimulatorComponent> graphics;
    boost::shared_ptr<ISimulatorComponent> gui;
    boost::shared_ptr<ISimulatorComponent> input;
    boost::shared_ptr<ISimulatorComponent> network;
    boost::shared_ptr<ISimulatorComponent> propertymanager;
    boost::shared_ptr<ISimulatorComponent> simulation;
    boost::shared_ptr<ISimulatorComponent> sound;
    boost::shared_ptr<ISimulatorComponent> task;
    boost::shared_ptr<ISimulatorComponent> test;
    boost::shared_ptr<ISimulatorComponent> tweaker;


    friend class SystemState;
    friend class State<STARTUP>;
    friend class State<GUI>;
    friend class State<ROUTESTARTUP>;
    friend class State<ROUTESHUTDOWN>;
    friend class State<SIMULATION>;
    friend class State<SHUTDOWN>;

};

    /// @}   group system
/// @}   group simulator
#endif // SYSTEM_H