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