source/libr2c2/layout.cpp

   1 #include <algorithm>
   2 #include <msp/core/maputils.h>
   3 #include <msp/core/refptr.h>
   4 #include <msp/datafile/parser.h>
   5 #include <msp/datafile/writer.h>
   6 #include <msp/io/print.h>
   7 #include <msp/time/utils.h>
   8 #include "block.h"
   9 #include "catalogue.h"
  10 #include "driver.h"
  11 #include "layout.h"
  12 #include "route.h"
  13 #include "signal.h"
  14 #include "signaltype.h"
  15 #include "track.h"
  16 #include "trackcircuit.h"
  17 #include "tracktype.h"
  18 #include "train.h"
  19 #include "vehicle.h"
  20 #include "vehicletype.h"
  21 #include "zone.h"
  22
  23 using namespace std;
  24 using namespace Msp;
  25
  26 namespace {
  27
  28 bool zone_order(const R2C2::Zone *z1, const R2C2::Zone *z2)
  29 {
  30         return z1->get_number()<z2->get_number();
  31 }
  32
  33 }
  34
  35
  36 namespace R2C2 {
  37
  38 Layout::Layout(Catalogue &c, Driver *d):
  39         catalogue(c),
  40         driver(d),
  41         next_turnout_id(0x800)
  42 { }
  43
  44 Layout::~Layout()
  45 {
  46         delete driver;
  47         driver = 0;
  48
  49         while(!trains.empty())
  50                 delete trains.begin()->second;
  51         track_chains.del<Route>();
  52         track_chains.del<Zone>();
  53         objects.del<Signal>();
  54         objects.del<Track>();
  55         track_chains.del<Block>();
  56 }
  57
  58 Driver &Layout::get_driver() const
  59 {
  60         if(!driver)
  61                 throw logic_error("!driver");
  62         return *driver;
  63 }
  64
  65 void Layout::add(Object &o)
  66 {
  67         if(objects.insert(o))
  68                 signal_object_added.emit(o);
  69 }
  70
  71 void Layout::add(Track &t)
  72 {
  73         if(objects.insert(t))
  74         {
  75                 // Blocks must be recreated first
  76                 create_blocks();
  77                 signal_object_added.emit(t);
  78         }
  79 }
  80
  81 void Layout::add(TrackChain &g)
  82 {
  83         if(track_chains.insert(g))
  84                 signal_track_chain_added.emit(g);
  85 }
  86
  87 void Layout::add(Block &b)
  88 {
  89         if(track_chains.insert(b))
  90         {
  91                 b.signal_reserved.connect(sigc::bind<0>(signal_block_reserved, sigc::ref(b)));
  92                 signal_track_chain_added.emit(b);
  93         }
  94 }
  95
  96 void Layout::add(Sensor &s)
  97 {
  98         if(sensors.insert(s))
  99         {
 100                 s.signal_state_changed.connect(sigc::bind<0>(sigc::mem_fun(this, &Layout::sensor_state_changed), sigc::ref(s)));
 101                 s.signal_state_changed.connect(sigc::bind<0>(signal_sensor_state_changed, sigc::ref(s)));
 102         }
 103 }
 104
 105 template<>
 106 const set<Object *> &Layout::get_all<Object>() const
 107 {
 108         return objects.get();
 109 }
 110
 111 template<>
 112 const set<Track *> &Layout::get_all<Track>() const
 113 {
 114         return objects.get<Track>();
 115 }
 116
 117 template<>
 118 const set<Signal *> &Layout::get_all<Signal>() const
 119 {
 120         return objects.get<Signal>();
 121 }
 122
 123 template<>
 124 const set<Vehicle *> &Layout::get_all<Vehicle>() const
 125 {
 126         return objects.get<Vehicle>();
 127 }
 128
 129 template<>
 130 const set<TrackChain *> &Layout::get_all<TrackChain>() const
 131 {
 132         return track_chains.get();
 133 }
 134
 135 template<>
 136 const set<Block *> &Layout::get_all<Block>() const
 137 {
 138         return track_chains.get<Block>();
 139 }
 140
 141 template<>
 142 const set<Route *> &Layout::get_all<Route>() const
 143 {
 144         return track_chains.get<Route>();
 145 }
 146
 147 template<>
 148 const set<Zone *> &Layout::get_all<Zone>() const
 149 {
 150         return track_chains.get<Zone>();
 151 }
 152
 153 template<>
 154 const set<Sensor *> &Layout::get_all<Sensor>() const
 155 {
 156         return sensors.get<Sensor>();
 157 }
 158
 159 template<>
 160 const set<TrackCircuit *> &Layout::get_all<TrackCircuit>() const
 161 {
 162         return sensors.get<TrackCircuit>();
 163 }
 164
 165 template<typename T>
 166 T *Layout::pick(const Ray &ray)
 167 {
 168         const set<Object *> &objs = objects.get();
 169         for(set<Object *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
 170                 if(T *t = dynamic_cast<T *>(*i))
 171                         if(t->collide_ray(ray))
 172                                 return t;
 173
 174         return 0;
 175 }
 176
 177 template Object *Layout::pick<Object>(const Ray &);
 178 template Track *Layout::pick<Track>(const Ray &);
 179 template Signal *Layout::pick<Signal>(const Ray &);
 180 template Vehicle *Layout::pick<Vehicle>(const Ray &);
 181
 182 void Layout::remove(Object &o)
 183 {
 184         if(objects.erase(o))
 185                 signal_object_removed.emit(o);
 186 }
 187
 188 void Layout::remove(Track &t)
 189 {
 190         if(objects.erase(t))
 191         {
 192                 // Blocks must be recreated first
 193                 create_blocks(t);
 194                 signal_object_removed.emit(t);
 195         }
 196 }
 197
 198 void Layout::remove(TrackChain &g)
 199 {
 200         if(track_chains.erase(g))
 201                 signal_track_chain_removed.emit(g);
 202 }
 203
 204 void Layout::remove(Sensor &s)
 205 {
 206         sensors.erase(s);
 207 }
 208
 209 unsigned Layout::allocate_turnout_id()
 210 {
 211         set<unsigned> used_ids;
 212         const set<Track *> &tracks = objects.get<Track>();
 213         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 214                 if((*i)->get_turnout_id())
 215                         used_ids.insert((*i)->get_turnout_id());
 216
 217         unsigned result = next_turnout_id;
 218         while(used_ids.count(result))
 219                 ++result;
 220         next_turnout_id = result+1;
 221
 222         return result;
 223 }
 224
 225 Block &Layout::get_block(unsigned id) const
 226 {
 227         const set<Block *> &blocks = track_chains.get<Block>();
 228         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
 229                 if((*i)->get_id()==id)
 230                         return **i;
 231
 232         throw key_error(id);
 233 }
 234
 235 void Layout::create_blocks()
 236 {
 237         set<Track *> used_tracks;
 238         const set<Block *> *blocks = &track_chains.get<Block>();
 239         for(set<Block *>::const_iterator i=blocks->begin(); i!=blocks->end(); ++i)
 240         {
 241                 const set<Track *> &btracks = (*i)->get_tracks();
 242                 used_tracks.insert(btracks.begin(), btracks.end());
 243         }
 244
 245         const set<Track *> &tracks = objects.get<Track>();
 246         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 247                 if(used_tracks.count(*i)==0)
 248                 {
 249                         Block *block = new Block(*this, **i);
 250                         used_tracks.insert(block->get_tracks().begin(), block->get_tracks().end());
 251                 }
 252
 253         blocks = &track_chains.get<Block>();
 254         for(set<Block *>::iterator i=blocks->begin(); i!=blocks->end(); ++i)
 255                 for(set<Block *>::iterator j=i; j!=blocks->end(); ++j)
 256                         if(j!=i)
 257                                 (*i)->check_link(**j);
 258 }
 259
 260 void Layout::create_blocks(Track &track)
 261 {
 262         /* Must collect the blocks in a set first while all tracks are still
 263         guaranteed to have blocks and to avoid duplicate deletes */
 264         set<Block *> del_blocks;
 265
 266         del_blocks.insert(&track.get_block());
 267
 268         const vector<Track *> &links = track.get_links();
 269         for(vector<Track *>::const_iterator i=links.begin(); i!=links.end(); ++i)
 270                 if(*i)
 271                         del_blocks.insert(&(*i)->get_block());
 272
 273         for(set<Block *>::iterator i=del_blocks.begin(); i!=del_blocks.end(); ++i)
 274                 delete *i;
 275
 276         create_blocks();
 277 }
 278
 279 Route &Layout::get_route(const string &name) const
 280 {
 281         const set<Route *> &routes = track_chains.get<Route>();
 282         for(set<Route *>::const_iterator i=routes.begin(); i!=routes.end(); ++i)
 283                 if((*i)->get_name()==name)
 284                         return **i;
 285         throw key_error(name);
 286 }
 287
 288 void Layout::update_routes()
 289 {
 290         const set<Route *> &routes = track_chains.get<Route>();
 291         for(set<Route *>::iterator i=routes.begin(); i!=routes.end(); ++i)
 292                 (*i)->update_turnouts();
 293 }
 294
 295 Layout::ZoneArray Layout::get_zones(const string &group) const
 296 {
 297         ZoneArray result;
 298         const set<Zone *> &zones = track_chains.get<Zone>();
 299         for(set<Zone *>::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 300                 if((*i)->get_group()==group)
 301                         result.push_back(*i);
 302
 303         sort(result.begin(), result.end(), zone_order);
 304
 305         return result;
 306 }
 307
 308 Zone &Layout::get_zone(const string &group, unsigned num) const
 309 {
 310         const set<Zone *> &zones = track_chains.get<Zone>();
 311         for(set<Zone *>::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 312                 if((*i)->get_group()==group && (*i)->get_number()==num)
 313                         return **i;
 314
 315         throw key_error(format("%s %d", group, num));
 316 }
 317
 318 void Layout::add_train(Train &t)
 319 {
 320         insert_unique(trains, t.get_address(), &t);
 321         signal_train_added.emit(t);
 322 }
 323
 324 Train &Layout::get_train(unsigned addr) const
 325 {
 326         return *get_item(trains, addr);
 327 }
 328
 329 void Layout::remove_train(Train &t)
 330 {
 331         if(trains.erase(t.get_address()))
 332                 signal_train_removed.emit(t);
 333 }
 334
 335 void Layout::tick()
 336 {
 337         if(driver)
 338                 driver->tick();
 339
 340         Time::TimeStamp t = Time::now();
 341         Time::TimeDelta dt;
 342         if(last_tick)
 343                 dt = t-last_tick;
 344         last_tick = t;
 345
 346         for(set<Sensor *>::iterator i=sensors.get().begin(); i!=sensors.get().end(); ++i)
 347                 (*i)->tick(dt);
 348         const set<Signal *> &signals = objects.get<Signal>();
 349         for(set<Signal *>::iterator i=signals.begin(); i!=signals.end(); ++i)
 350                 (*i)->tick(dt);
 351         for(map<unsigned, Train *>::iterator i=trains.begin(); i!=trains.end(); ++i)
 352                 i->second->tick(t, dt);
 353 }
 354
 355 void Layout::emergency(const string &msg)
 356 {
 357         if(driver)
 358                 driver->halt(true);
 359         IO::print("Emergency: %s\n", msg);
 360         signal_emergency.emit(msg);
 361 }
 362
 363 void Layout::save(const string &fn) const
 364 {
 365         IO::BufferedFile out(fn, IO::M_WRITE);
 366         DataFile::Writer writer(out);
 367
 368         if(!base.empty())
 369                 writer.write((DataFile::Statement("base"), base));
 370
 371         const set<Track *> &tracks = objects.get<Track>();
 372         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 373         {
 374                 DataFile::Statement st("track");
 375                 st.append((*i)->get_type().get_article_number());
 376                 (*i)->save(st.sub);
 377                 writer.write(st);
 378         }
 379
 380         const set<Signal *> &signals = objects.get<Signal>();
 381         for(set<Signal *>::const_iterator i=signals.begin(); i!=signals.end(); ++i)
 382         {
 383                 DataFile::Statement st("signal");
 384                 st.append((*i)->get_type().get_article_number());
 385                 (*i)->save(st.sub);
 386                 writer.write(st);
 387         }
 388
 389         const set<Route *> &routes = track_chains.get<Route>();
 390         for(set<Route *>::const_iterator i=routes.begin(); i!=routes.end(); ++i)
 391         {
 392                 if((*i)->is_temporary())
 393                         continue;
 394
 395                 DataFile::Statement st("route");
 396                 (*i)->save(st.sub);
 397                 writer.write(st);
 398         }
 399
 400         const set<Zone *> &zones = track_chains.get<Zone>();
 401         for(set<Zone *>::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 402         {
 403                 DataFile::Statement st("zone");
 404                 (*i)->save(st.sub);
 405                 writer.write(st);
 406         }
 407 }
 408
 409 void Layout::save_dynamic(const string &fn) const
 410 {
 411         IO::BufferedFile out(fn, IO::M_WRITE);
 412         DataFile::Writer writer(out);
 413
 414         const set<Track *> &tracks = objects.get<Track>();
 415         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 416                 if(unsigned tid = (*i)->get_turnout_id())
 417                         writer.write((DataFile::Statement("turnout"), tid, (*i)->get_active_path()));
 418
 419         for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
 420         {
 421                 DataFile::Statement st("train");
 422                 st.append(i->second->get_locomotive_type().get_article_number());
 423                 st.append(i->second->get_address());
 424                 st.append(i->second->get_protocol());
 425                 i->second->save(st.sub);
 426                 writer.write(st);
 427         }
 428 }
 429
 430 void Layout::sensor_state_changed(Sensor &sensor, Sensor::State state)
 431 {
 432         if(state==Sensor::ACTIVE)
 433         {
 434                 Block *block = 0;
 435                 if(TrackCircuit *tc = dynamic_cast<TrackCircuit *>(&sensor))
 436                         block = &tc->get_block();
 437
 438                 if(block && !block->get_train())
 439                         emergency(format("Unreserved sensor %d triggered", sensor.get_address()));
 440         }
 441 }
 442
 443
 444 template<typename B>
 445 Layout::Storage<B>::~Storage()
 446 {
 447         while(!base.empty())
 448                 delete *base.begin();
 449 }
 450
 451 template<typename B>
 452 bool Layout::Storage<B>::insert(B &b)
 453 {
 454         bool result = base.insert(&b).second;
 455         if(result)
 456                 caches.clear();
 457         return result;
 458 }
 459
 460 template<typename B>
 461 bool Layout::Storage<B>::erase(B &b)
 462 {
 463         bool result = base.erase(&b);
 464         if(result)
 465                 caches.clear();
 466         return result;
 467 }
 468
 469 template<typename B>
 470 template<typename T>
 471 const set<T *> &Layout::Storage<B>::get() const
 472 {
 473         for(list<Variant>::const_iterator i=caches.begin(); i!=caches.end(); ++i)
 474                 if(i->check_type<set<T *> >())
 475                         return i->value<set<T *> >();
 476
 477         caches.push_back(set<T *>());
 478         set<T *> &result = caches.back().value<set<T *> >();
 479         for(typename set<B *>::const_iterator i=base.begin(); i!=base.end(); ++i)
 480                 if(T *t = dynamic_cast<T *>(*i))
 481                         result.insert(t);
 482
 483         return result;
 484 }
 485
 486 template<typename B>
 487 template<typename T>
 488 void Layout::Storage<B>::del()
 489 {
 490         set<T *> ts = get<T>();
 491         for(typename set<T *>::iterator i=ts.begin(); i!=ts.end(); ++i)
 492                 if(base.count(*i))
 493                         delete *i;
 494 }
 495
 496
 497 Layout::Loader::Loader(Layout &l):
 498         DataFile::ObjectLoader<Layout>(l),
 499         new_tracks(false)
 500 {
 501         add("base",  &Layout::base);
 502         add("route", static_cast<void (Loader::*)()>(&Loader::route));
 503         add("signal", &Loader::signal);
 504         add("track", static_cast<void (Loader::*)(ArticleNumber)>(&Loader::track));
 505         add("train", static_cast<void (Loader::*)(ArticleNumber, unsigned, const std::string &)>(&Loader::train));
 506         add("turnout", &Loader::turnout);
 507         add("zone",  &Loader::zone);
 508
 509         // Deprecated aliases
 510         add("route", static_cast<void (Loader::*)(const string &)>(&Loader::route));
 511         add("track", static_cast<void (Loader::*)(unsigned)>(&Loader::track));
 512         add("train", static_cast<void (Loader::*)(unsigned, unsigned, const std::string &)>(&Loader::train));
 513 }
 514
 515 void Layout::Loader::route()
 516 {
 517         Route *rte = new Route(obj);
 518         load_sub(*rte);
 519 }
 520
 521 void Layout::Loader::route(const string &n)
 522 {
 523         Route *rte = new Route(obj);
 524         rte->set_name(n);
 525         load_sub(*rte);
 526 }
 527
 528 void Layout::Loader::signal(ArticleNumber art_nr)
 529 {
 530         Signal *sig = new Signal(obj, obj.catalogue.get_signal(art_nr));
 531         load_sub(*sig);
 532 }
 533
 534 void Layout::Loader::track(unsigned art_nr)
 535 {
 536         track(ArticleNumber(art_nr));
 537 }
 538
 539 void Layout::Loader::track(ArticleNumber art_nr)
 540 {
 541         Track *trk = new Track(obj, obj.catalogue.get_track(art_nr));
 542         load_sub(*trk);
 543         new_tracks = true;
 544         const set<Track *> &tracks = obj.objects.get<Track>();
 545         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 546                 if(*i!=trk)
 547                         trk->link_to(**i);
 548 }
 549
 550 void Layout::Loader::train(unsigned art_nr, unsigned addr, const std::string &proto)
 551 {
 552         train(ArticleNumber(art_nr), addr, proto);
 553 }
 554
 555 void Layout::Loader::train(ArticleNumber art_nr, unsigned addr, const std::string &proto)
 556 {
 557         Train *trn = new Train(obj, obj.catalogue.get_vehicle(art_nr), addr, proto);
 558         load_sub(*trn);
 559 }
 560
 561 void Layout::Loader::turnout(unsigned addr, unsigned path)
 562 {
 563         if(obj.driver)
 564                 obj.driver->set_turnout(addr, path);
 565 }
 566
 567 void Layout::Loader::zone()
 568 {
 569         Zone *zne = new Zone(obj);
 570         load_sub(*zne);
 571 }
 572
 573 } // namespace R2C2