source/libmarklin/layout.cpp

   1 /* $Id$
   2
   3 This file is part of the MSP Märklin suite
   4 Copyright © 2006-2010  Mikkosoft Productions, Mikko Rasa
   5 Distributed under the GPL
   6 */
   7
   8 #include <algorithm>
   9 #include <msp/core/refptr.h>
  10 #include <msp/datafile/parser.h>
  11 #include <msp/datafile/writer.h>
  12 #include <msp/time/utils.h>
  13 #include "block.h"
  14 #include "catalogue.h"
  15 #include "driver.h"
  16 #include "layout.h"
  17 #include "locotype.h"
  18 #include "route.h"
  19 #include "track.h"
  20 #include "tracktype.h"
  21 #include "train.h"
  22
  23 using namespace std;
  24 using namespace Msp;
  25
  26 namespace Marklin {
  27
  28 Layout::Layout(Catalogue &c, Driver *d):
  29         catalogue(c),
  30         driver(d)
  31 { }
  32
  33 Layout::~Layout()
  34 {
  35         delete driver;
  36         while(!trains.empty())
  37                 delete trains.begin()->second;
  38         while(!routes.empty())
  39                 delete routes.begin()->second;
  40         while(!tracks.empty())
  41                 delete *tracks.begin();
  42         while(!blocks.empty())
  43                 delete *blocks.begin();
  44 }
  45
  46 Driver &Layout::get_driver() const
  47 {
  48         if(!driver)
  49                 throw InvalidState("No driver");
  50         return *driver;
  51 }
  52
  53 void Layout::add_track(Track &t)
  54 {
  55         if(tracks.insert(&t).second)
  56         {
  57                 create_blocks();
  58                 signal_track_added.emit(t);
  59         }
  60 }
  61
  62 void Layout::remove_track(Track &t)
  63 {
  64         if(tracks.erase(&t))
  65         {
  66                 create_blocks(t);
  67                 signal_track_removed.emit(t);
  68         }
  69 }
  70
  71 void Layout::add_block(Block &b)
  72 {
  73         blocks.insert(&b);
  74 }
  75
  76 Block &Layout::get_block(unsigned id) const
  77 {
  78         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
  79                 if((*i)->get_id()==id)
  80                         return **i;
  81
  82         throw KeyError("Unknown block", lexical_cast(id));
  83 }
  84
  85 Block &Layout::get_block_by_track(const Track &t) const
  86 {
  87         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
  88                 if((*i)->get_tracks().count(const_cast<Track *>(&t)))
  89                         return **i;
  90
  91         throw InvalidParameterValue("No block found for track");
  92 }
  93
  94 void Layout::create_blocks()
  95 {
  96         set<Track *> used_tracks;
  97         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
  98         {
  99                 const set<Track *> &btracks = (*i)->get_tracks();
 100                 used_tracks.insert(btracks.begin(), btracks.end());
 101         }
 102
 103         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 104                 if(used_tracks.count(*i)==0)
 105                 {
 106                         Block *block = new Block(*this, **i);
 107                         used_tracks.insert(block->get_tracks().begin(), block->get_tracks().end());
 108                 }
 109
 110         for(set<Block *>::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 111                 for(set<Block *>::iterator j=i; j!=blocks.end(); ++j)
 112                         if(j!=i)
 113                                 (*i)->check_link(**j);
 114 }
 115
 116 void Layout::create_blocks(const Track &track)
 117 {
 118         const vector<Track *> &links = track.get_links();
 119         for(set<Block *>::iterator i=blocks.begin(); i!=blocks.end();)
 120         {
 121                 bool del = (*i)->get_tracks().count(const_cast<Track *>(&track));
 122                 for(vector<Track *>::const_iterator j=links.begin(); (!del && j!=links.end()); ++j)
 123                         del = (*i)->get_tracks().count(*j);
 124
 125                 if(del)
 126                         delete *i++;
 127                 else
 128                         ++i;
 129         }
 130
 131         create_blocks();
 132 }
 133
 134 void Layout::remove_block(Block &b)
 135 {
 136         blocks.erase(&b);
 137 }
 138
 139 void Layout::add_route(Route &r)
 140 {
 141         if(routes.count(r.get_name()))
 142                 throw KeyError("Duplicate route name", r.get_name());
 143
 144         routes[r.get_name()] = &r;
 145         signal_route_added.emit(r);
 146 }
 147
 148 Route &Layout::get_route(const string &name) const
 149 {
 150         map<string, Route *>::const_iterator i = routes.find(name);
 151         if(i==routes.end())
 152                 throw KeyError("Unknown route", name);
 153         return *i->second;
 154 }
 155
 156 void Layout::remove_route(Route &r)
 157 {
 158         if(routes.erase(r.get_name()))
 159                 signal_route_removed.emit(r);
 160 }
 161
 162 void Layout::add_train(Train &t)
 163 {
 164         if(trains.count(t.get_address()))
 165                 throw KeyError("Duplicate train address", lexical_cast(t.get_address()));
 166
 167         trains[t.get_address()] = &t;
 168         signal_train_added.emit(t);
 169 }
 170
 171 Train &Layout::get_train(unsigned addr) const
 172 {
 173         map<unsigned, Train *>::const_iterator i = trains.find(addr);
 174         if(i==trains.end())
 175                 throw KeyError("Unknown train", lexical_cast(addr));
 176         return *i->second;
 177 }
 178
 179 void Layout::remove_train(Train &t)
 180 {
 181         if(trains.erase(t.get_address()))
 182                 signal_train_removed.emit(t);
 183 }
 184
 185 void Layout::add_vehicle(Vehicle &v)
 186 {
 187         if(vehicles.insert(&v).second)
 188                 signal_vehicle_added.emit(v);
 189 }
 190
 191 void Layout::remove_vehicle(Vehicle &v)
 192 {
 193         if(vehicles.erase(&v))
 194                 signal_vehicle_removed.emit(v);
 195 }
 196
 197 void Layout::tick()
 198 {
 199         if(driver)
 200                 driver->tick();
 201
 202         Time::TimeStamp t = Time::now();
 203         Time::TimeDelta dt;
 204         if(last_tick)
 205                 dt = t-last_tick;
 206         last_tick = t;
 207
 208         for(map<unsigned, Train *>::iterator i=trains.begin(); i!=trains.end(); ++i)
 209                 i->second->tick(t, dt);
 210 }
 211
 212 void Layout::save(const string &fn)
 213 {
 214         IO::BufferedFile out(fn, IO::M_WRITE);
 215         DataFile::Writer writer(out);
 216
 217         if(!base.empty())
 218                 writer.write((DataFile::Statement("base"), base));
 219
 220         for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 221         {
 222                 DataFile::Statement st("track");
 223                 st.append((*i)->get_type().get_article_number());
 224                 (*i)->save(st.sub);
 225                 writer.write(st);
 226         }
 227
 228         for(map<string, Route *>::iterator i=routes.begin(); i!=routes.end(); ++i)
 229         {
 230                 DataFile::Statement st("route");
 231                 st.append(i->first);
 232                 i->second->save(st.sub);
 233                 writer.write(st);
 234         }
 235 }
 236
 237 void Layout::save_trains(const string &fn)
 238 {
 239         IO::BufferedFile out(fn, IO::M_WRITE);
 240         DataFile::Writer writer(out);
 241
 242         for(map<unsigned, Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
 243         {
 244                 DataFile::Statement st("train");
 245                 st.append(i->second->get_locomotive_type().get_article_number());
 246                 st.append(i->second->get_address());
 247                 i->second->save(st.sub);
 248                 writer.write(st);
 249         }
 250 }
 251
 252 void Layout::check_links()
 253 {
 254         for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 255                 (*i)->break_links();
 256
 257         list<Track *> flext;
 258         for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 259         {
 260                 if((*i)->get_flex())
 261                         flext.push_back(*i);
 262                 else
 263                 {
 264                         for(set<Track *>::iterator j=i; j!=tracks.end(); ++j)
 265                                 if(j!=i)
 266                                         (*i)->snap_to(**j, true);
 267                 }
 268         }
 269
 270         for(list<Track *>::iterator i=flext.begin(); i!=flext.end(); ++i)
 271                 for(set<Track *>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
 272                         if(*j!=*i)
 273                                 (*i)->snap_to(**j, true);
 274 }
 275
 276 void Layout::check_routes()
 277 {
 278         for(map<string, Route *>::iterator i=routes.begin(); i!=routes.end(); ++i)
 279         {
 280                 /* We must copy the turnout map, since adding tracks to the route will
 281                 (temporarily) mess it up */
 282                 const map<unsigned, int> turnouts = i->second->get_turnouts();
 283
 284                 // Find any turnout in the route
 285                 Track *track = 0;
 286                 unsigned trk_path = 0;
 287                 for(set<Track *>::const_iterator j=tracks.begin(); j!=tracks.end(); ++j)
 288                 {
 289                         map<unsigned, int>::const_iterator k = turnouts.find((*j)->get_turnout_id());
 290                         if(k!=turnouts.end())
 291                         {
 292                                 track = *j;
 293                                 trk_path = k->second;
 294                                 break;
 295                         }
 296                 }
 297
 298                 if(!track)
 299                         continue;
 300
 301                 // Find an applicable endpoint
 302                 const vector<Endpoint> &eps = track->get_type().get_endpoints();
 303                 unsigned ep = 0;
 304                 for(unsigned j=0; j<eps.size(); ++j)
 305                         if(eps[j].paths&(1<<trk_path))
 306                         {
 307                                 ep = j;
 308                                 break;
 309                         }
 310
 311                 Track *start = 0;
 312                 while(1)
 313                 {
 314                         // Traverse the track and get the next one
 315                         unsigned out_ep = track->traverse(ep, trk_path);
 316                         Track *next = track->get_links()[out_ep];
 317                         if(!next || next == start)
 318                                 break;
 319
 320                         ep = next->get_endpoint_by_link(*track);
 321                         if(next->get_type().is_turnout())
 322                         {
 323                                 // Select correct path across the turnout, or break if we hit an unknown turnout
 324                                 map<unsigned, int>::const_iterator j = turnouts.find(next->get_turnout_id());
 325                                 if(j==turnouts.end())
 326                                         break;
 327                                 trk_path = j->second;
 328                         }
 329                         else
 330                         {
 331                                 trk_path = 0;
 332
 333                                 /* Start adding tracks when we find the first non-turnout.  This
 334                                 prevents the occurrence of ambiguities while adding the tracks */
 335                                 if(!start)
 336                                         start = next;
 337                         }
 338
 339                         if(start)
 340                                 i->second->add_track(*next);
 341
 342                         track = next;
 343                 }
 344         }
 345 }
 346
 347
 348 Layout::Loader::Loader(Layout &l):
 349         DataFile::BasicLoader<Layout>(l),
 350         new_tracks(false)
 351 {
 352         add("base",  &Layout::base);
 353         add("route", &Loader::route);
 354         add("track", &Loader::track);
 355         add("train", &Loader::train);
 356 }
 357
 358 void Layout::Loader::finish()
 359 {
 360         if(new_tracks)
 361                 obj.check_links();
 362         obj.check_routes();
 363
 364         for(set<Track *>::iterator i=obj.tracks.begin(); i!=obj.tracks.end(); ++i)
 365                 (*i)->check_slope();
 366 }
 367
 368 void Layout::Loader::route(const string &n)
 369 {
 370         Route *rte = new Route(obj, n);
 371         load_sub(*rte);
 372 }
 373
 374 void Layout::Loader::track(unsigned art_nr)
 375 {
 376         Track *trk = new Track(obj, obj.catalogue.get_track(art_nr));
 377         load_sub(*trk);
 378         new_tracks = true;
 379 }
 380
 381 void Layout::Loader::train(unsigned art_nr, unsigned addr)
 382 {
 383         Train *trn = new Train(obj, obj.catalogue.get_locomotive(art_nr), addr);
 384         load_sub(*trn);
 385 }
 386
 387 } // namespace Marklin