simgear/structure/subsystem_mgr.cxx

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