src/Main/fgfs.cxx

   1 #include "fgfs.hxx"
   2
   3 #include <simgear/debug/logstream.hxx>
   4 #include <simgear/misc/exception.hxx>
   5
   6 #include "globals.hxx"
   7 #include "fg_props.hxx"
   8
   9
  10 \f
  11 ////////////////////////////////////////////////////////////////////////
  12 // Implementation of FGSubsystem
  13 ////////////////////////////////////////////////////////////////////////
  14
  15
  16 FGSubsystem::FGSubsystem ()
  17   : _suspended(false)
  18 {
  19 }
  20
  21 FGSubsystem::~FGSubsystem ()
  22 {
  23 }
  24
  25 void
  26 FGSubsystem::init ()
  27 {
  28 }
  29
  30 void
  31 FGSubsystem::reinit ()
  32 {
  33 }
  34
  35 void
  36 FGSubsystem::bind ()
  37 {
  38 }
  39
  40 void
  41 FGSubsystem::unbind ()
  42 {
  43 }
  44
  45 void
  46 FGSubsystem::suspend ()
  47 {
  48   _suspended = true;
  49 }
  50
  51 void
  52 FGSubsystem::suspend (bool suspended)
  53 {
  54   _suspended = suspended;
  55 }
  56
  57 void
  58 FGSubsystem::resume ()
  59 {
  60   _suspended = false;
  61 }
  62
  63 bool
  64 FGSubsystem::is_suspended () const
  65 {
  66   if (!_freeze_master_node.valid())
  67     _freeze_master_node = fgGetNode("/sim/freeze/master", true);
  68   return _suspended || _freeze_master_node->getBoolValue();
  69 }
  70
  71
  72 \f
  73 ////////////////////////////////////////////////////////////////////////
  74 // Implementation of FGSubsystemGroup.
  75 ////////////////////////////////////////////////////////////////////////
  76
  77 FGSubsystemGroup::FGSubsystemGroup ()
  78 {
  79 }
  80
  81 FGSubsystemGroup::~FGSubsystemGroup ()
  82 {
  83     for (unsigned int i = 0; i < _members.size(); i++)
  84         delete _members[i];
  85 }
  86
  87 void
  88 FGSubsystemGroup::init ()
  89 {
  90     for (unsigned int i = 0; i < _members.size(); i++)
  91         _members[i]->subsystem->init();
  92 }
  93
  94 void
  95 FGSubsystemGroup::reinit ()
  96 {
  97     for (unsigned int i = 0; i < _members.size(); i++)
  98         _members[i]->subsystem->reinit();
  99 }
 100
 101 void
 102 FGSubsystemGroup::bind ()
 103 {
 104     for (unsigned int i = 0; i < _members.size(); i++)
 105         _members[i]->subsystem->bind();
 106 }
 107
 108 void
 109 FGSubsystemGroup::unbind ()
 110 {
 111     for (unsigned int i = 0; i < _members.size(); i++)
 112         _members[i]->subsystem->unbind();
 113 }
 114
 115 void
 116 FGSubsystemGroup::update (double delta_time_sec)
 117 {
 118     for (unsigned int i = 0; i < _members.size(); i++)
 119         _members[i]->update(delta_time_sec); // indirect call
 120 }
 121
 122 void
 123 FGSubsystemGroup::suspend ()
 124 {
 125     for (unsigned int i = 0; i < _members.size(); i++)
 126         _members[i]->subsystem->suspend();
 127 }
 128
 129 void
 130 FGSubsystemGroup::resume ()
 131 {
 132     for (unsigned int i = 0; i < _members.size(); i++)
 133         _members[i]->subsystem->resume();
 134 }
 135
 136 bool
 137 FGSubsystemGroup::is_suspended () const
 138 {
 139     return false;
 140 }
 141
 142 void
 143 FGSubsystemGroup::set_subsystem (const string &name, FGSubsystem * subsystem,
 144                                  double min_step_sec)
 145 {
 146     Member * member = get_member(name, true);
 147     if (member->subsystem != 0)
 148         delete member->subsystem;
 149     member->name = name;
 150     member->subsystem = subsystem;
 151     member->min_step_sec = min_step_sec;
 152 }
 153
 154 FGSubsystem *
 155 FGSubsystemGroup::get_subsystem (const string &name)
 156 {
 157     Member * member = get_member(name);
 158     if (member != 0)
 159         return member->subsystem;
 160     else
 161         return 0;
 162 }
 163
 164 void
 165 FGSubsystemGroup::remove_subsystem (const string &name)
 166 {
 167     for (unsigned int i = 0; i < _members.size(); i++) {
 168         if (name == _members[i]->name) {
 169             _members.erase(_members.begin() + i);
 170             return;
 171         }
 172     }
 173 }
 174
 175 bool
 176 FGSubsystemGroup::has_subsystem (const string &name) const
 177 {
 178     return (((FGSubsystemGroup *)this)->get_member(name) != 0);
 179 }
 180
 181 FGSubsystemGroup::Member *
 182 FGSubsystemGroup::get_member (const string &name, bool create)
 183 {
 184     for (unsigned int i = 0; i < _members.size(); i++) {
 185         if (_members[i]->name == name)
 186             return _members[i];
 187     }
 188     if (create) {
 189         Member * member = new Member;
 190         _members.push_back(member);
 191         return member;
 192     } else {
 193         return 0;
 194     }
 195 }
 196
 197
 198 \f
 199 ////////////////////////////////////////////////////////////////////////
 200 // Implementation of FGSubsystemGroup::Member
 201 ////////////////////////////////////////////////////////////////////////
 202
 203
 204 FGSubsystemGroup::Member::Member ()
 205     : name(""),
 206       subsystem(0),
 207       min_step_sec(0),
 208       elapsed_sec(0)
 209 {
 210 }
 211
 212 FGSubsystemGroup::Member::Member (const Member &)
 213 {
 214     Member();
 215 }
 216
 217 FGSubsystemGroup::Member::~Member ()
 218 {
 219                                 // FIXME: causes a crash
 220 //     delete subsystem;
 221 }
 222
 223 void
 224 FGSubsystemGroup::Member::update (double delta_time_sec)
 225 {
 226     elapsed_sec += delta_time_sec;
 227     if (elapsed_sec >= min_step_sec) {
 228         if (!subsystem->is_suspended()) {
 229             subsystem->update(elapsed_sec);
 230             elapsed_sec = 0;
 231         }
 232     }
 233 }
 234
 235
 236 \f
 237 ////////////////////////////////////////////////////////////////////////
 238 // Implementation of FGSubsystemMgr.
 239 ////////////////////////////////////////////////////////////////////////
 240
 241
 242 FGSubsystemMgr::FGSubsystemMgr ()
 243 {
 244 }
 245
 246 FGSubsystemMgr::~FGSubsystemMgr ()
 247 {
 248 }
 249
 250 void
 251 FGSubsystemMgr::init ()
 252 {
 253     for (int i = 0; i < MAX_GROUPS; i++)
 254             _groups[i].init();
 255 }
 256
 257 void
 258 FGSubsystemMgr::reinit ()
 259 {
 260     for (int i = 0; i < MAX_GROUPS; i++)
 261             _groups[i].reinit();
 262 }
 263
 264 void
 265 FGSubsystemMgr::bind ()
 266 {
 267     for (int i = 0; i < MAX_GROUPS; i++)
 268         _groups[i].bind();
 269 }
 270
 271 void
 272 FGSubsystemMgr::unbind ()
 273 {
 274     for (int i = 0; i < MAX_GROUPS; i++)
 275         _groups[i].unbind();
 276 }
 277
 278 void
 279 FGSubsystemMgr::update (double delta_time_sec)
 280 {
 281     for (int i = 0; i < MAX_GROUPS; i++) {
 282         _groups[i].update(delta_time_sec);
 283     }
 284 }
 285
 286 void
 287 FGSubsystemMgr::suspend ()
 288 {
 289     for (int i = 0; i < MAX_GROUPS; i++)
 290         _groups[i].suspend();
 291 }
 292
 293 void
 294 FGSubsystemMgr::resume ()
 295 {
 296     for (int i = 0; i < MAX_GROUPS; i++)
 297         _groups[i].resume();
 298 }
 299
 300 bool
 301 FGSubsystemMgr::is_suspended () const
 302 {
 303     return false;
 304 }
 305
 306 void
 307 FGSubsystemMgr::add (const char * name, FGSubsystem * subsystem,
 308                      GroupType group, double min_time_sec)
 309 {
 310     SG_LOG(SG_GENERAL, SG_INFO, "Adding subsystem " << name);
 311     get_group(group)->set_subsystem(name, subsystem, min_time_sec);
 312
 313     if (_subsystem_map.find(name) != _subsystem_map.end()) {
 314         SG_LOG(SG_GENERAL, SG_ALERT, "Adding duplicate subsystem " << name);
 315         throw sg_exception("duplicate subsystem");
 316     }
 317     _subsystem_map[name] = subsystem;
 318 }
 319
 320 FGSubsystemGroup *
 321 FGSubsystemMgr::get_group (GroupType group)
 322 {
 323     return &(_groups[group]);
 324 }
 325
 326 FGSubsystem *
 327 FGSubsystemMgr::get_subsystem (const string &name)
 328 {
 329     map<string,FGSubsystem *>::iterator s =_subsystem_map.find(name);
 330
 331     if (s == _subsystem_map.end())
 332         return 0;
 333     else
 334         return s->second;
 335 }
 336
 337 // end of fgfs.cxx