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 (int i = 0; i < _members.size(); i++)
  84         delete _members[i];
  85 }
  86
  87 void
  88 FGSubsystemGroup::init ()
  89 {
  90     for (int i = 0; i < _members.size(); i++)
  91         _members[i]->subsystem->init();
  92 }
  93
  94 void
  95 FGSubsystemGroup::reinit ()
  96 {
  97     for (int i = 0; i < _members.size(); i++)
  98         _members[i]->subsystem->reinit();
  99 }
 100
 101 void
 102 FGSubsystemGroup::bind ()
 103 {
 104     for (int i = 0; i < _members.size(); i++)
 105         _members[i]->subsystem->bind();
 106 }
 107
 108 void
 109 FGSubsystemGroup::unbind ()
 110 {
 111     for (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     if (!is_suspended()) {
 119         for (int i = 0; i < _members.size(); i++)
 120             _members[i]->update(delta_time_sec); // indirect call
 121     }
 122 }
 123
 124 void
 125 FGSubsystemGroup::suspend ()
 126 {
 127     FGSubsystem::suspend();
 128     for (int i = 0; i < _members.size(); i++)
 129         _members[i]->subsystem->suspend();
 130 }
 131
 132 void
 133 FGSubsystemGroup::resume ()
 134 {
 135     FGSubsystem::resume();
 136     for (int i = 0; i < _members.size(); i++)
 137         _members[i]->subsystem->resume();
 138 }
 139
 140 bool
 141 FGSubsystemGroup::is_suspended () const
 142 {
 143     return FGSubsystem::is_suspended();
 144 }
 145
 146 void
 147 FGSubsystemGroup::set_subsystem (const string &name, FGSubsystem * subsystem,
 148                                  double min_step_sec)
 149 {
 150     Member * member = get_member(name, true);
 151     if (member->subsystem != 0)
 152         delete member->subsystem;
 153     member->name = name;
 154     member->subsystem = subsystem;
 155     member->min_step_sec = min_step_sec;
 156 }
 157
 158 FGSubsystem *
 159 FGSubsystemGroup::get_subsystem (const string &name)
 160 {
 161     Member * member = get_member(name);
 162     if (member != 0)
 163         return member->subsystem;
 164     else
 165         return 0;
 166 }
 167
 168 void
 169 FGSubsystemGroup::remove_subsystem (const string &name)
 170 {
 171     for (int i = 0; i < _members.size(); i++) {
 172         if (name == _members[i]->name) {
 173             _members.erase(_members.begin() + i);
 174             return;
 175         }
 176     }
 177 }
 178
 179 bool
 180 FGSubsystemGroup::has_subsystem (const string &name) const
 181 {
 182     return (((FGSubsystemGroup *)this)->get_member(name) != 0);
 183 }
 184
 185 FGSubsystemGroup::Member *
 186 FGSubsystemGroup::get_member (const string &name, bool create)
 187 {
 188     for (int i = 0; i < _members.size(); i++) {
 189         if (_members[i]->name == name)
 190             return _members[i];
 191     }
 192     if (create) {
 193         Member * member = new Member;
 194         _members.push_back(member);
 195         return member;
 196     } else {
 197         return 0;
 198     }
 199 }
 200
 201
 202 \f
 203 ////////////////////////////////////////////////////////////////////////
 204 // Implementation of FGSubsystemGroup::Member
 205 ////////////////////////////////////////////////////////////////////////
 206
 207
 208 FGSubsystemGroup::Member::Member ()
 209     : name(""),
 210       subsystem(0),
 211       min_step_sec(0),
 212       elapsed_sec(0)
 213 {
 214 }
 215
 216 FGSubsystemGroup::Member::Member (const Member &)
 217 {
 218     Member();
 219 }
 220
 221 FGSubsystemGroup::Member::~Member ()
 222 {
 223                                 // FIXME: causes a crash
 224 //     delete subsystem;
 225 }
 226
 227 void
 228 FGSubsystemGroup::Member::update (double delta_time_sec)
 229 {
 230     elapsed_sec += delta_time_sec;
 231     if (elapsed_sec >= min_step_sec) {
 232         subsystem->update(delta_time_sec);
 233         elapsed_sec -= min_step_sec;
 234     }
 235 }
 236
 237
 238 \f
 239 ////////////////////////////////////////////////////////////////////////
 240 // Implementation of FGSubsystemMgr.
 241 ////////////////////////////////////////////////////////////////////////
 242
 243
 244 FGSubsystemMgr::FGSubsystemMgr ()
 245 {
 246 }
 247
 248 FGSubsystemMgr::~FGSubsystemMgr ()
 249 {
 250 }
 251
 252 void
 253 FGSubsystemMgr::init ()
 254 {
 255     for (int i = 0; i < MAX_GROUPS; i++)
 256             _groups[i].init();
 257 }
 258
 259 void
 260 FGSubsystemMgr::reinit ()
 261 {
 262     for (int i = 0; i < MAX_GROUPS; i++)
 263             _groups[i].reinit();
 264 }
 265
 266 void
 267 FGSubsystemMgr::bind ()
 268 {
 269     for (int i = 0; i < MAX_GROUPS; i++)
 270         _groups[i].bind();
 271 }
 272
 273 void
 274 FGSubsystemMgr::unbind ()
 275 {
 276     for (int i = 0; i < MAX_GROUPS; i++)
 277         _groups[i].unbind();
 278 }
 279
 280 void
 281 FGSubsystemMgr::update (double delta_time_sec)
 282 {
 283     if (!is_suspended()) {
 284         for (int i = 0; i < MAX_GROUPS; i++)
 285             _groups[i].update(delta_time_sec);
 286     }
 287 }
 288
 289 void
 290 FGSubsystemMgr::suspend ()
 291 {
 292     FGSubsystem::suspend();
 293     for (int i = 0; i < MAX_GROUPS; i++)
 294         _groups[i].suspend();
 295 }
 296
 297 void
 298 FGSubsystemMgr::resume ()
 299 {
 300     FGSubsystem::resume();
 301     for (int i = 0; i < MAX_GROUPS; i++)
 302         _groups[i].resume();
 303 }
 304
 305 bool
 306 FGSubsystemMgr::is_suspended () const
 307 {
 308     return FGSubsystem::is_suspended();
 309 }
 310
 311 void
 312 FGSubsystemMgr::add (const char * name, FGSubsystem * subsystem,
 313                      GroupType group, double min_time_sec)
 314 {
 315     SG_LOG(SG_GENERAL, SG_INFO, "Adding subsystem " << name);
 316     get_group(group)->set_subsystem(name, subsystem, min_time_sec);
 317
 318     if (_subsystem_map.find(name) != _subsystem_map.end()) {
 319         SG_LOG(SG_GENERAL, SG_ALERT, "Adding duplicate subsystem " << name);
 320         throw sg_exception("duplicate subsystem");
 321     }
 322     _subsystem_map[name] = subsystem;
 323 }
 324
 325 FGSubsystemGroup *
 326 FGSubsystemMgr::get_group (GroupType group)
 327 {
 328     return &(_groups[group]);
 329 }
 330
 331 FGSubsystem *
 332 FGSubsystemMgr::get_subsystem (const string &name)
 333 {
 334     map<string,FGSubsystem *>::iterator s =_subsystem_map.find(name);
 335
 336     if (s == _subsystem_map.end())
 337         return 0;
 338     else
 339         return s->second;
 340 }
 341
 342 // end of fgfs.cxx