source/libr2c2/layout.cpp

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