root/simulator/trunk/src/simulator/interface.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.
//
//
// //////////////////// Interfaces /////////////////////////////////
/// \file
/// Header file for all simulator interfaces using ISimulatorComponent base class.


#ifndef _
    #define _(x) x //i18n tag
#endif // _

#ifndef String
    #ifdef _UNICODE
        typedef std::wstring String;
    #else
        typedef std::string String;
    #endif //_UNICODE
#endif //String

/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup simulatorcomponent "Simulator Components"
    /// @{


    class ISystem;

    /// \interface ISimulatorComponent
    /// ISimulatorComponent is the common interface for simulator components.
    /// This is an abstract class to insure the simulator components
    /// have a common interface.
    /// \remarks
    /// \par Simulator interfaces.
    /// All calls between simulator components should
    /// be represented by an abstract function in the
    /// following protocol classes.
    /// This will reduce coupling leaving the only
    /// the hazard of a cast from ISimulatorComponent
    /// to the interface for the function
    /// (Example dynamic_cast<ISimulatorComponent*>(IGraphics*) ).
    /// \remarks
    /// \par Requirement for a protocol class
    /// - Does not contain or inherit from a non-protocol class.
    /// - The class has a non-inline virtual destructor.
    /// - All other member functions are pure virtual.
    class ISimulatorComponent
    {
    public:
        virtual void startup() = 0;
        virtual void operator()() = 0;
        virtual void shutdown() = 0;


        /// Protocol classes may require a non-inline virtual
        /// destructor for some compilers.
        /// from "Large-Scale C++ Software Design", Lakos, John, 1996
        virtual ~ISimulatorComponent(){}
    };

    /// \interface IGraphics
    /// IGraphics is the simulation interface to Ogre.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes.
    class IGraphics : public ISimulatorComponent
    {
    public:
        virtual bool isClosed() const = 0;
        virtual bool isVisible() const = 0;

        /// Get time from last render
        /// \return milliseconds from last graphics render
        virtual unsigned long getFrameMilliseconds() = 0;

        virtual ~IGraphics(){}
    };

    /// \interface ITask
    /// ITask is the simulation interface to it's micro threads.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to control background tasks
    /// for game enities and the game enities events. The class will register
    /// and unregister events from other interfaces and game enities.
    class ITask : public ISimulatorComponent
    {
    public:
        virtual bool addScript( const char* module, const char* script, const clock_t max, const int priority ) = 0;

        virtual ~ITask(){}
    };

    /// \interface ISound
    /// ISound is the simulation interface to OpenAL.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to control sound for
    /// game enities.
    class ISound : public ISimulatorComponent
    {
    public:

        virtual ~ISound(){}
    };

    /// \interface IAi
    /// IAi is the simulation interface to control game enities.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to control game enities.
    class IAi : public ISimulatorComponent
    {
    public:

        virtual ~IAi(){}
    };

    /// \interface IInput
    /// IInput is the simulation interface to OIS.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to generate events.
    class IInput : public ISimulatorComponent
    {
    public:

        virtual ~IInput(){}
    };

    /// \interface IGui
    /// IGui is the simulation interface to GUI.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to show 2d overlays and associate
    /// them with input/output events and tasks.
    class IGui : public ISimulatorComponent
    {
    public:

        virtual ~IGui(){}
    };

    /// \interface INetwork
    /// INetwork is the simulation interface to a peer network.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to execute tasks that preform
    /// network input/output.
    class INetwork : public ISimulatorComponent
    {
    public:

        virtual ~INetwork(){}
    };

    /// \interface IConsoleClient
    /// IConsoleClient is the simulation interface to the console utility.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used show information to, and retrieve
    /// debug and tweaker settings from the console user.
    class IConsoleClient : public ISimulatorComponent
    {
    public:

        virtual ~IConsoleClient(){}
    };

    /// \interface IFactory
    /// IFactory is the simulation interface used to generate game entities.
    /// This is an abstract class to insure a common interface for the use of
    /// the ISystem classes. This class is interface between the route data files
    /// and the Ogre resource system.
    class IFactory : public ISimulatorComponent
    {
    public:

        virtual ~IFactory(){}
    };

    /// \interface IPropertyManager
    /// IPropertyManager is the simulation interface used to retrieve the rights
    /// to game media. This is an abstract class to insure a common inteface
    /// for the use of the ISystem classes. This class is interface to the
    /// Propermanager utility.
    class IPropertyManager : public ISimulatorComponent
    {
    public:

        virtual ~IPropertyManager(){}
    };

    /// \interface ISimulation
    /// ISimulation is the simulation interface for moviable or antimated
    /// game enities. This is an abstract class to insure a common inteface
    /// for the use of the ISystem classes. This class is used to control
    /// background simulation of the enitiestasks
    /// for game enities and the game enities.
    class ISimulation : public ISimulatorComponent
    {
    public:

        virtual ~ISimulation(){}
    };

    /// \interface ITest
    /// ITest is the simulation interface to internal tests.
    /// This is an abstract class to insure a common inteface for the use of
    /// the ISystem classes. This class is used to test routines and devices
    /// and send results to the console. The class will register
    /// and unregister test with the console.
    class ITest : public ISimulatorComponent
    {
    public:

        virtual ~ITest(){}
    };

    /// \interface ISystem
    /// ISystem is the simulation main loop.
    /// This is an abstract class to insure a common inteface for the use of
    /// all other interface classes.
    class ISystem : public ISimulatorComponent
    {
    public:
        virtual bool  running() const = 0;
        virtual bool  anyState() const = 0;
        virtual void  setOptions( const boost::program_options::variables_map& map ) = 0;
        virtual IAi*              getAiInterface()  = 0;
        virtual IConsoleClient*   getConsoleClientInterface()  = 0;
        virtual IFactory*         getFactoryInterface()  = 0;
        virtual IGraphics*        getGraphicsInterface()  = 0;
        virtual IGui*             getGuiInterface()  = 0;
        virtual IInput*           getInputInterface()  = 0;
        virtual INetwork*         getNetworkInterface()  = 0;
        virtual IPropertyManager* getPropertyManagerInterface()  = 0;
        virtual ISimulation*      getSimulationInterface()  = 0;
        virtual ISound*           getSoundInterface()  = 0;
        virtual ISystem*          getSystemInterface()  = 0;
        virtual ITask*            getTaskInterface()  = 0;
        virtual ITest*            getTestInterface()  = 0;
        /// Get time from last render
        /// \return milliseconds from last graphics render
        virtual unsigned long     getFrameMilliseconds() = 0;
        virtual ~ISystem(){}
    };


    /// @}   group simulatorcomponent
/// @}   group simulator