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