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 "vehicletype.h"
  20 #include "zone.h"
  21
  22 using namespace std;
  23 using namespace Msp;
  24
  25 namespace {
  26
  27 bool zone_order(const R2C2::Zone *z1, const R2C2::Zone *z2)
  28 {
  29         return z1->get_number()<z2->get_number();
  30 }
  31
  32 }
  33
  34
  35 namespace R2C2 {
  36
  37 Layout::Layout(Catalogue &c, Driver *d):
  38         catalogue(c),
  39         driver(d),
  40         next_turnout_id(0x800)
  41 { }
  42
  43 Layout::~Layout()
  44 {
  45         delete driver;
  46         driver = 0;
  47
  48         while(!trains.empty())
  49                 delete trains.begin()->second;
  50         while(!routes.empty())
  51                 delete *routes.begin();
  52         while(!zones.empty())
  53                 delete *zones.begin();
  54         while(!signals.empty())
  55                 delete *signals.begin();
  56         while(!tracks.empty())
  57                 delete *tracks.begin();
  58         while(!blocks.empty())
  59                 delete *blocks.begin();
  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_track(Track &t)
  70 {
  71         if(tracks.insert(&t).second)
  72         {
  73                 create_blocks();
  74                 signal_track_added.emit(t);
  75         }
  76 }
  77
  78 Track *Layout::pick_track(const Ray &ray)
  79 {
  80         return pick(tracks, ray);
  81 }
  82
  83 void Layout::remove_track(Track &t)
  84 {
  85         if(tracks.erase(&t))
  86         {
  87                 create_blocks(t);
  88                 signal_track_removed.emit(t);
  89         }
  90 }
  91
  92 unsigned Layout::allocate_turnout_id()
  93 {
  94         set<unsigned> used_ids;
  95         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  96                 if((*i)->get_turnout_id())
  97                         used_ids.insert((*i)->get_turnout_id());
  98
  99         unsigned result = next_turnout_id;
 100         while(used_ids.count(result))
 101                 ++result;
 102         next_turnout_id = result+1;
 103
 104         return result;
 105 }
 106
 107 void Layout::add_signal(Signal &s)
 108 {
 109         if(signals.insert(&s).second)
 110                 signal_signal_added.emit(s);
 111 }
 112
 113 Signal *Layout::pick_signal(const Ray &ray)
 114 {
 115         return pick(signals, ray);
 116 }
 117
 118 void Layout::remove_signal(Signal &s)
 119 {
 120         if(signals.erase(&s))
 121                 signal_signal_removed.emit(s);
 122 }
 123
 124 Object *Layout::pick_object(const Ray &ray)
 125 {
 126         if(Object *obj = pick_track(ray))
 127                 return obj;
 128         else if((obj = pick_signal(ray)))
 129                 return obj;
 130         return 0;
 131 }
 132
 133 template<typename T>
 134 T *Layout::pick(const set<T *> &objs, const Ray &ray)
 135 {
 136         for(typename set<T *>::const_iterator i=objs.begin(); i!=objs.end(); ++i)
 137                 if((*i)->collide_ray(ray))
 138                         return *i;
 139
 140         return 0;
 141 }
 142
 143 void Layout::add_block(Block &b)
 144 {
 145         blocks.insert(&b);
 146         b.signal_reserved.connect(sigc::bind<0>(signal_block_reserved, sigc::ref(b)));
 147 }
 148
 149 Block &Layout::get_block(unsigned id) const
 150 {
 151         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
 152                 if((*i)->get_id()==id)
 153                         return **i;
 154
 155         throw key_error(id);
 156 }
 157
 158 void Layout::create_blocks()
 159 {
 160         set<Track *> used_tracks;
 161         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
 162         {
 163                 const set<Track *> &btracks = (*i)->get_tracks();
 164                 used_tracks.insert(btracks.begin(), btracks.end());
 165         }
 166
 167         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 168                 if(used_tracks.count(*i)==0)
 169                 {
 170                         Block *block = new Block(*this, **i);
 171                         used_tracks.insert(block->get_tracks().begin(), block->get_tracks().end());
 172                 }
 173
 174         for(set<Block *>::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 175                 for(set<Block *>::iterator j=i; j!=blocks.end(); ++j)
 176                         if(j!=i)
 177                                 (*i)->check_link(**j);
 178 }
 179
 180 void Layout::create_blocks(Track &track)
 181 {
 182         /* Must collect the blocks in a set first while all tracks are still
 183         guaranteed to have blocks and to avoid duplicate deletes */
 184         set<Block *> del_blocks;
 185
 186         del_blocks.insert(&track.get_block());
 187
 188         const vector<Track *> &links = track.get_links();
 189         for(vector<Track *>::const_iterator i=links.begin(); i!=links.end(); ++i)
 190                 if(*i)
 191                         del_blocks.insert(&(*i)->get_block());
 192
 193         for(set<Block *>::iterator i=del_blocks.begin(); i!=del_blocks.end(); ++i)
 194                 delete *i;
 195
 196         create_blocks();
 197 }
 198
 199 void Layout::remove_block(Block &b)
 200 {
 201         blocks.erase(&b);
 202 }
 203
 204 void Layout::add_route(Route &r)
 205 {
 206         if(routes.insert(&r).second)
 207                 signal_route_added.emit(r);
 208 }
 209
 210 Route &Layout::get_route(const string &name) const
 211 {
 212         for(set<Route *>::const_iterator i=routes.begin(); i!=routes.end(); ++i)
 213                 if((*i)->get_name()==name)
 214                         return **i;
 215         throw key_error(name);
 216 }
 217
 218 void Layout::update_routes()
 219 {
 220         for(set<Route *>::iterator i=routes.begin(); i!=routes.end(); ++i)
 221                 (*i)->update_turnouts();
 222 }
 223
 224 void Layout::remove_route(Route &r)
 225 {
 226         if(routes.erase(&r))
 227                 signal_route_removed.emit(r);
 228 }
 229
 230 void Layout::add_zone(Zone &z)
 231 {
 232         if(zones.insert(&z).second)
 233                 signal_zone_added.emit(z);
 234 }
 235
 236 Layout::ZoneArray Layout::get_zones(const string &group) const
 237 {
 238         ZoneArray result;
 239         for(ZoneSet::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 240                 if((*i)->get_group()==group)
 241                         result.push_back(*i);
 242
 243         sort(result.begin(), result.end(), zone_order);
 244
 245         return result;
 246 }
 247
 248 Zone &Layout::get_zone(const string &group, unsigned num) const
 249 {
 250         for(ZoneSet::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 251                 if((*i)->get_group()==group && (*i)->get_number()==num)
 252                         return **i;
 253
 254         throw key_error(format("%s %d", group, num));
 255 }
 256
 257 void Layout::remove_zone(Zone &z)
 258 {
 259         if(zones.erase(&z))
 260                 signal_zone_removed.emit(z);
 261 }
 262
 263 void Layout::add_train(Train &t)
 264 {
 265         insert_unique(trains, t.get_address(), &t);
 266         signal_train_added.emit(t);
 267 }
 268
 269 Train &Layout::get_train(unsigned addr) const
 270 {
 271         return *get_item(trains, addr);
 272 }
 273
 274 void Layout::remove_train(Train &t)
 275 {
 276         if(trains.erase(t.get_address()))
 277                 signal_train_removed.emit(t);
 278 }
 279
 280 void Layout::add_vehicle(Vehicle &v)
 281 {
 282         if(vehicles.insert(&v).second)
 283                 signal_vehicle_added.emit(v);
 284 }
 285
 286 void Layout::remove_vehicle(Vehicle &v)
 287 {
 288         if(vehicles.erase(&v))
 289                 signal_vehicle_removed.emit(v);
 290 }
 291
 292 void Layout::add_sensor(Sensor &s)
 293 {
 294         if(sensors.insert(&s).second)
 295         {
 296                 s.signal_state_changed.connect(sigc::bind<0>(sigc::mem_fun(this, &Layout::sensor_state_changed), sigc::ref(s)));
 297                 s.signal_state_changed.connect(sigc::bind<0>(signal_sensor_state_changed, sigc::ref(s)));
 298         }
 299 }
 300
 301 void Layout::remove_sensor(Sensor &s)
 302 {
 303         sensors.erase(&s);
 304 }
 305
 306 void Layout::tick()
 307 {
 308         if(driver)
 309                 driver->tick();
 310
 311         Time::TimeStamp t = Time::now();
 312         Time::TimeDelta dt;
 313         if(last_tick)
 314                 dt = t-last_tick;
 315         last_tick = t;
 316
 317         for(set<Sensor *>::iterator i=sensors.begin(); i!=sensors.end(); ++i)
 318                 (*i)->tick(dt);
 319         for(set<Signal *>::iterator i=signals.begin(); i!=signals.end(); ++i)
 320                 (*i)->tick(dt);
 321         for(map<unsigned, Train *>::iterator i=trains.begin(); i!=trains.end(); ++i)
 322                 i->second->tick(t, dt);
 323 }
 324
 325 void Layout::emergency(const string &msg)
 326 {
 327         if(driver)
 328                 driver->halt(true);
 329         IO::print("Emergency: %s\n", msg);
 330         signal_emergency.emit(msg);
 331 }
 332
 333 void Layout::save(const string &fn) const
 334 {
 335         IO::BufferedFile out(fn, IO::M_WRITE);
 336         DataFile::Writer writer(out);
 337
 338         if(!base.empty())
 339                 writer.write((DataFile::Statement("base"), base));
 340
 341         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 342         {
 343                 DataFile::Statement st("track");
 344                 st.append((*i)->get_type().get_article_number());
 345                 (*i)->save(st.sub);
 346                 writer.write(st);
 347         }
 348
 349         for(set<Signal *>::const_iterator i=signals.begin(); i!=signals.end(); ++i)
 350         {
 351                 DataFile::Statement st("signal");
 352                 st.append((*i)->get_type().get_article_number());
 353                 (*i)->save(st.sub);
 354                 writer.write(st);
 355         }
 356
 357         for(set<Route *>::const_iterator i=routes.begin(); i!=routes.end(); ++i)
 358         {
 359                 if((*i)->is_temporary())
 360                         continue;
 361
 362                 DataFile::Statement st("route");
 363                 (*i)->save(st.sub);
 364                 writer.write(st);
 365         }
 366
 367         for(ZoneSet::const_iterator i=zones.begin(); i!=zones.end(); ++i)
 368         {
 369                 DataFile::Statement st("zone");
 370                 (*i)->save(st.sub);
 371                 writer.write(st);
 372         }
 373 }
 374
 375 void Layout::save_dynamic(const string &fn) const
 376 {
 377         IO::BufferedFile out(fn, IO::M_WRITE);
 378         DataFile::Writer writer(out);
 379
 380         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 381                 if(unsigned tid = (*i)->get_turnout_id())
 382                         writer.write((DataFile::Statement("turnout"), tid, (*i)->get_active_path()));
 383
 384         for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
 385         {
 386                 DataFile::Statement st("train");
 387                 st.append(i->second->get_locomotive_type().get_article_number());
 388                 st.append(i->second->get_address());
 389                 st.append(i->second->get_protocol());
 390                 i->second->save(st.sub);
 391                 writer.write(st);
 392         }
 393 }
 394
 395 void Layout::sensor_state_changed(Sensor &sensor, Sensor::State state)
 396 {
 397         if(state==Sensor::ACTIVE)
 398         {
 399                 Block *block = 0;
 400                 if(TrackCircuit *tc = dynamic_cast<TrackCircuit *>(&sensor))
 401                         block = &tc->get_block();
 402
 403                 if(block && !block->get_train())
 404                         emergency(format("Unreserved sensor %d triggered", sensor.get_address()));
 405         }
 406 }
 407
 408
 409 Layout::Loader::Loader(Layout &l):
 410         DataFile::ObjectLoader<Layout>(l),
 411         new_tracks(false)
 412 {
 413         add("base",  &Layout::base);
 414         add("route", static_cast<void (Loader::*)()>(&Loader::route));
 415         add("signal", &Loader::signal);
 416         add("track", static_cast<void (Loader::*)(ArticleNumber)>(&Loader::track));
 417         add("train", static_cast<void (Loader::*)(ArticleNumber, unsigned, const std::string &)>(&Loader::train));
 418         add("turnout", &Loader::turnout);
 419         add("zone",  &Loader::zone);
 420
 421         // Deprecated aliases
 422         add("route", static_cast<void (Loader::*)(const string &)>(&Loader::route));
 423         add("track", static_cast<void (Loader::*)(unsigned)>(&Loader::track));
 424         add("train", static_cast<void (Loader::*)(unsigned, unsigned, const std::string &)>(&Loader::train));
 425 }
 426
 427 void Layout::Loader::route()
 428 {
 429         Route *rte = new Route(obj);
 430         load_sub(*rte);
 431 }
 432
 433 void Layout::Loader::route(const string &n)
 434 {
 435         Route *rte = new Route(obj);
 436         rte->set_name(n);
 437         load_sub(*rte);
 438 }
 439
 440 void Layout::Loader::signal(ArticleNumber art_nr)
 441 {
 442         Signal *sig = new Signal(obj, obj.catalogue.get_signal(art_nr));
 443         load_sub(*sig);
 444 }
 445
 446 void Layout::Loader::track(unsigned art_nr)
 447 {
 448         track(ArticleNumber(art_nr));
 449 }
 450
 451 void Layout::Loader::track(ArticleNumber art_nr)
 452 {
 453         Track *trk = new Track(obj, obj.catalogue.get_track(art_nr));
 454         load_sub(*trk);
 455         new_tracks = true;
 456         for(set<Track *>::iterator i=obj.tracks.begin(); i!=obj.tracks.end(); ++i)
 457                 if(*i!=trk)
 458                         trk->link_to(**i);
 459 }
 460
 461 void Layout::Loader::train(unsigned art_nr, unsigned addr, const std::string &proto)
 462 {
 463         train(ArticleNumber(art_nr), addr, proto);
 464 }
 465
 466 void Layout::Loader::train(ArticleNumber art_nr, unsigned addr, const std::string &proto)
 467 {
 468         Train *trn = new Train(obj, obj.catalogue.get_vehicle(art_nr), addr, proto);
 469         load_sub(*trn);
 470 }
 471
 472 void Layout::Loader::turnout(unsigned addr, unsigned path)
 473 {
 474         if(obj.driver)
 475                 obj.driver->set_turnout(addr, path);
 476 }
 477
 478 void Layout::Loader::zone()
 479 {
 480         Zone *zne = new Zone(obj);
 481         load_sub(*zne);
 482 }
 483
 484 } // namespace R2C2