subsystem_mgr.hxx

// Written by David Megginson, started 2000-12
//
// Copyright (C) 2000  David Megginson, david@megginson.com
//
// 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.
//
// $Id: subsystem__mgr_8hxx-source.html,v 1.4 2008/12/18 22:33:05 curt Exp $


#ifndef __SUBSYSTEM_MGR_HXX
#define __SUBSYSTEM_MGR_HXX 1


#include <simgear/compiler.h>

#include <string>
#include <map>
#include <vector>

using std::map;
using std::vector;
using std::string;

#include <simgear/props/props.hxx>
#include <simgear/timing/timestamp.hxx>
#include "SGSmplstat.hxx"


class TimingInfo
{
private:
    string eventName;
    SGTimeStamp time;

public: 
    TimingInfo(string name, SGTimeStamp &t) { eventName = name; time = t;};
    string getName() { return eventName; };
    SGTimeStamp getTime() { return time; };
};

typedef vector<TimingInfo> eventTimeVec;
typedef vector<TimingInfo>::iterator eventTimeVecIterator;



class SGSubsystem : public SGReferenced
{
public:

  SGSubsystem ();

  virtual ~SGSubsystem ();


  virtual void init ();


  virtual void postinit ();


  virtual void reinit ();


  virtual void bind ();


  virtual void unbind ();


  virtual void update (double delta_time_sec) = 0;


  virtual void suspend ();


  virtual void suspend (bool suspended);


  virtual void resume ();


  virtual bool is_suspended () const;


  void updateExecutionTime(double time);

  void printTimingInformation();

  void stamp(string name);
  


protected:

  bool _suspended;

  eventTimeVec timingInfo;
  //int test;

};



class SGSubsystemGroup : public SGSubsystem
{
public:

    SGSubsystemGroup ();
    virtual ~SGSubsystemGroup ();

    virtual void init ();
    virtual void postinit ();
    virtual void reinit ();
    virtual void bind ();
    virtual void unbind ();
    virtual void update (double delta_time_sec);
    virtual void suspend ();
    virtual void resume ();
    virtual bool is_suspended () const;

    virtual void set_subsystem (const string &name,
                                SGSubsystem * subsystem,
                                double min_step_sec = 0);
    virtual SGSubsystem * get_subsystem (const string &name);
    virtual void remove_subsystem (const string &name);
    virtual bool has_subsystem (const string &name) const;

    void collectDebugTiming(bool collect);

private:

    struct Member {

        Member ();
        Member (const Member &member);
        virtual ~Member ();

        virtual void update (double delta_time_sec);
        void printTimingInformation(double time);
        void printTimingStatistics();
        void updateExecutionTime(double time);
        double getTimeWarningThreshold();
        void collectDebugTiming (bool collect) { collectTimeStats = collect; };

        SampleStatistic timeStat;
        string name;
        SGSubsystem * subsystem;
        double min_step_sec;
        double elapsed_sec;
        bool collectTimeStats;
    };

    Member * get_member (const string &name, bool create = false);

    vector<Member *> _members;
};



class SGSubsystemMgr : public SGSubsystem
{
public:

    enum GroupType {
        INIT = 0,
        GENERAL,
        MAX_GROUPS
    };

    SGSubsystemMgr ();
    virtual ~SGSubsystemMgr ();

    virtual void init ();
    virtual void postinit ();
    virtual void reinit ();
    virtual void bind ();
    virtual void unbind ();
    virtual void update (double delta_time_sec);
    virtual void suspend ();
    virtual void resume ();
    virtual bool is_suspended () const;

    virtual void add (const char * name,
                      SGSubsystem * subsystem,
                      GroupType group = GENERAL, 
                      double min_time_sec = 0);

    virtual SGSubsystemGroup * get_group (GroupType group);

    virtual SGSubsystem * get_subsystem(const string &name);

   void collectDebugTiming(bool collect);

private:

    SGSubsystemGroup _groups[MAX_GROUPS];
    map<string,SGSubsystem *> _subsystem_map;

};



#endif // __SUBSYSTEM_MGR_HXX

---