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