source/libr2c2/timetable.cpp

   1 #include <msp/strings/format.h>
   2 #include <msp/time/units.h>
   3 #include "block.h"
   4 #include "catalogue.h"
   5 #include "driver.h"
   6 #include "layout.h"
   7 #include "timetable.h"
   8 #include "train.h"
   9
  10 using namespace std;
  11 using namespace Msp;
  12
  13 namespace R2C2 {
  14
  15 Timetable::Timetable(Train &t):
  16         TrainAI(t),
  17         enabled(false),
  18         current_row(0),
  19         executing(true),
  20         pending_block(0),
  21         pending_train(0),
  22         arrived(false)
  23 {
  24         train.signal_advanced.connect(sigc::mem_fun(this, &Timetable::train_advanced));
  25         train.signal_ai_event.connect(sigc::mem_fun(this, &Timetable::event));
  26         Layout &layout = train.get_layout();
  27         layout.signal_block_state_changed.connect(sigc::mem_fun(this, &Timetable::block_state_changed));
  28         layout.signal_block_reserved.connect(sigc::mem_fun(this, &Timetable::block_reserved));
  29 }
  30
  31 void Timetable::set_enabled(bool e)
  32 {
  33         enabled = e;
  34 }
  35
  36 void Timetable::reset()
  37 {
  38         current_row = 0;
  39         wait_timeout = Time::TimeStamp();
  40         pending_block = 0;
  41         executing = true;
  42 }
  43
  44 void Timetable::clear()
  45 {
  46         rows.clear();
  47         reset();
  48 }
  49
  50 void Timetable::append(const Row &row)
  51 {
  52         rows.push_back(row);
  53 }
  54
  55 void Timetable::insert(unsigned i, const Row &row)
  56 {
  57         if(i>rows.size())
  58                 throw out_of_range("Timetable::insert");
  59
  60         rows.insert(rows.begin()+i, row);
  61         if(i<=current_row)
  62                 ++current_row;
  63 }
  64
  65 const Timetable::Row &Timetable::get_row(unsigned i) const
  66 {
  67         if(i>=rows.size())
  68                 throw out_of_range("Timetable::get_row");
  69         return rows[i];
  70 }
  71
  72 void Timetable::tick(const Time::TimeStamp &t, const Time::TimeDelta &)
  73 {
  74         if(rows.empty() || !enabled)
  75                 return;
  76
  77         if(wait_timeout && t>=wait_timeout)
  78         {
  79                 wait_timeout = Time::TimeStamp();
  80                 current_row = (current_row+1)%rows.size();
  81                 executing = true;
  82         }
  83
  84         if(executing)
  85         {
  86                 Row &row = rows[current_row];
  87                 switch(row.type)
  88                 {
  89                 case GOTO_SENSOR:
  90                         arrived = false;
  91                         train.ai_message(Message("set-destination-block", &get_sensor(row.get_param<unsigned>(0))));
  92                         break;
  93                 case GOTO_ZONE:
  94                         arrived = false;
  95                         train.ai_message(Message("set-destination-zone", &get_zone(row.get_param<string>(0))));
  96                         break;
  97                 case TRAVEL_TO:
  98                         {
  99                                 Block *block = &get_sensor(row.get_param<unsigned>(0));
 100                                 if(block->get_train()!=&train || block->get_state()<Block::MAYBE_ACTIVE)
 101                                 {
 102                                         pending_block = block;
 103                                         pending_train = &train;
 104                                         executing = false;
 105                                 }
 106                         }
 107                         break;
 108                 case TRAVEL_PAST:
 109                         pending_block = &get_turnout(row.get_param<unsigned>(0)).get_block();
 110                         pending_train = (pending_block->get_train()==&train ? 0 : &train);
 111                         executing = false;
 112                         break;
 113                 case WAIT_TIME:
 114                         wait_timeout = t+row.get_param<unsigned>(0)*Time::sec;
 115                         executing = false;
 116                         break;
 117                 case WAIT_UNTIL:
 118                         {
 119                                 unsigned unixtime = t.to_unixtime();
 120                                 unsigned mod = row.get_param<unsigned>(1);
 121                                 unsigned secs = ((mod+row.get_param<unsigned>(0))-(unixtime%mod))%mod;
 122                                 wait_timeout = t+secs*Time::sec;
 123                                 executing = false;
 124                         }
 125                         break;
 126                 case WAIT_TRAIN:
 127                         {
 128                                 Train *other_train = &train.get_layout().get_train(row.get_param<unsigned>(0));
 129                                 Block *block = &get_sensor(row.get_param<unsigned>(1));
 130                                 if(block->get_train()!=other_train || block->get_state()<Block::MAYBE_ACTIVE)
 131                                 {
 132                                         pending_train = other_train;
 133                                         pending_block = block;
 134                                         executing = false;
 135                                 }
 136                         }
 137                         break;
 138                 case ARRIVE:
 139                         if(!arrived)
 140                                 executing = false;
 141                         arrived = false;
 142                         break;
 143                 case SPEED:
 144                         if(!arrived)
 145                         {
 146                                 float speed = row.get_param<unsigned>(0)/3.6*train.get_layout().get_catalogue().get_scale();
 147                                 train.ai_message(Message("set-target-speed", speed));
 148                         }
 149                         break;
 150                 case REVERSE:
 151                         train.ai_message(Message("toggle-reverse"));
 152                         break;
 153                 case ROUTE:
 154                         train.ai_message(Message("set-route", &train.get_layout().get_route(row.get_param<string>(0))));
 155                         break;
 156                 }
 157
 158                 if(executing)
 159                         current_row = (current_row+1)%rows.size();
 160         }
 161 }
 162
 163 void Timetable::save(list<DataFile::Statement> &st) const
 164 {
 165         for(vector<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
 166                 st.push_back(i->save());
 167 }
 168
 169 Block &Timetable::get_sensor(unsigned id)
 170 {
 171         return train.get_layout().get_block(id|0x1000);
 172 }
 173
 174 Track &Timetable::get_turnout(unsigned id)
 175 {
 176         Block &block = train.get_layout().get_block(id|0x2000);
 177         return **block.get_tracks().begin();
 178 }
 179
 180 Zone &Timetable::get_zone(const string &name)
 181 {
 182         string::size_type space = name.rfind(' ');
 183         if(space==string::npos || space==0)
 184                 throw invalid_argument("Timetable::get_zone");
 185         unsigned number = lexical_cast<unsigned>(name.substr(space+1));
 186         return train.get_layout().get_zone(name.substr(0, space), number);
 187 }
 188
 189 void Timetable::block_state_changed(Block &block, Block::State state)
 190 {
 191         if(rows.empty() || !enabled)
 192                 return;
 193
 194         if(&block==pending_block && block.get_train()==pending_train && state>=Block::MAYBE_ACTIVE)
 195         {
 196                 pending_block = 0;
 197                 current_row = (current_row+1)%rows.size();
 198                 executing = true;
 199         }
 200 }
 201
 202 void Timetable::block_reserved(Block &block, Train *trn)
 203 {
 204         if(rows.empty() || !enabled)
 205                 return;
 206
 207         if(&block==pending_block && trn==pending_train)
 208         {
 209                 Row &row = rows[current_row];
 210                 if(row.type==TRAVEL_PAST && !pending_train)
 211                 {
 212                         pending_block = 0;
 213                         current_row = (current_row+1)%rows.size();
 214                         executing = true;
 215                 }
 216         }
 217 }
 218
 219 void Timetable::train_advanced(Block &block)
 220 {
 221         if(rows.empty() || !enabled)
 222                 return;
 223
 224         Row &row = rows[current_row];
 225         if(row.type==TRAVEL_PAST && &block==pending_block && pending_train)
 226                 pending_train = 0;
 227 }
 228
 229 void Timetable::event(TrainAI &, const Message &ev)
 230 {
 231         if(ev.type=="arrived")
 232         {
 233                 if(rows.empty() || !enabled)
 234                         return;
 235
 236                 Row &row = rows[current_row];
 237                 if(row.type==ARRIVE)
 238                 {
 239                         current_row = (current_row+1)%rows.size();
 240                         executing = true;
 241                 }
 242                 else
 243                         arrived = true;
 244         }
 245 }
 246
 247
 248 Timetable::Row::Row(RowType t):
 249         type(t)
 250 { }
 251
 252 template<typename T>
 253 Timetable::Row::Row(RowType t, const T &p):
 254         type(t)
 255 {
 256         params.push_back(p);
 257 }
 258
 259 template<typename T>
 260 const T &Timetable::Row::get_param(unsigned i) const
 261 {
 262         if(i>=params.size())
 263                 throw out_of_range("Timetable::Row::get_param");
 264         return params[i].value<T>();
 265 }
 266
 267 string Timetable::Row::str() const
 268 {
 269         switch(type)
 270         {
 271         case GOTO_SENSOR:
 272                 return format("set route to sensor %d", get_param<unsigned>(0));
 273         case GOTO_ZONE:
 274                 return "set route to "+get_param<string>(0);
 275         case TRAVEL_TO:
 276                 return format("travel to sensor %d", get_param<unsigned>(0));
 277         case TRAVEL_PAST:
 278                 return format("travel past turnout %d", get_param<unsigned>(0));
 279         case WAIT_TIME:
 280                 return format("wait for %d seconds", get_param<unsigned>(0));
 281         case WAIT_UNTIL:
 282                 return format("wait until %d mod %d seconds", get_param<unsigned>(0), get_param<unsigned>(1));
 283         case WAIT_TRAIN:
 284                 return format("wait for train %d at sensor %d", get_param<unsigned>(0), get_param<unsigned>(1));
 285         case ARRIVE:
 286                 return "travel until arrival";
 287         case SPEED:
 288                 return format("set speed %d km/h", get_param<unsigned>(0));
 289         case REVERSE:
 290                 return "reverse";
 291         case ROUTE:
 292                 return "set route "+get_param<string>(0);
 293         default:
 294                 return "invalid row";
 295         }
 296 }
 297
 298 DataFile::Statement Timetable::Row::save() const
 299 {
 300         switch(type)
 301         {
 302         case GOTO_SENSOR:
 303                 return DataFile::Statement("goto_sensor"), get_param<unsigned>(0);
 304         case GOTO_ZONE:
 305                 return DataFile::Statement("goto_zone"), get_param<string>(0);
 306         case TRAVEL_TO:
 307                 return DataFile::Statement("travel_to"), get_param<unsigned>(0);
 308         case TRAVEL_PAST:
 309                 return DataFile::Statement("travel_past"), get_param<unsigned>(0);
 310         case WAIT_TIME:
 311                 return DataFile::Statement("wait"), get_param<unsigned>(0);
 312         case WAIT_UNTIL:
 313                 return DataFile::Statement("wait_until"), get_param<unsigned>(0), get_param<unsigned>(1);
 314         case WAIT_TRAIN:
 315                 return DataFile::Statement("wait_train"), get_param<unsigned>(0), get_param<unsigned>(1);
 316         case ARRIVE:
 317                 return DataFile::Statement("arrive");
 318         case SPEED:
 319                 return DataFile::Statement("speed"), get_param<unsigned>(0);
 320         case REVERSE:
 321                 return DataFile::Statement("reverse");
 322         case ROUTE:
 323                 return DataFile::Statement("route"), get_param<string>(0);
 324         default:
 325                 return DataFile::Statement();
 326         }
 327 }
 328
 329 Timetable::Row Timetable::Row::parse(const string &s)
 330 {
 331         if(!s.compare(0, 7, "travel "))
 332         {
 333                 if(!s.compare(7, 10, "to sensor "))
 334                         return Row(TRAVEL_TO, lexical_cast<unsigned>(s.substr(17)));
 335                 else if(!s.compare(7, 13, "past turnout "))
 336                         return Row(TRAVEL_PAST, lexical_cast<unsigned>(s.substr(20)));
 337                 else if(!s.compare(7, string::npos, "until arrival"))
 338                         return Row(ARRIVE);
 339         }
 340         else if(!s.compare(0, 9, "wait for "))
 341         {
 342                 if(isdigit(s[9]))
 343                 {
 344                         unsigned nondigit = 10;
 345                         while(nondigit<s.size() && isdigit(s[nondigit]))
 346                                 ++nondigit;
 347                         return Row(WAIT_TIME, lexical_cast<unsigned>(s.substr(9, nondigit-9)));
 348                 }
 349                 else if(!s.compare(9, 6, "train "))
 350                 {
 351                         string::size_type at = s.find(" at sensor ", 15);
 352                         if(at!=string::npos)
 353                         {
 354                                 Row row(WAIT_TRAIN, lexical_cast<unsigned>(s.substr(15, at-15)));
 355                                 row.params.push_back(lexical_cast<unsigned>(s.substr(at+11)));
 356                                 return row;
 357                         }
 358                 }
 359         }
 360         else if(!s.compare(0, 11, "wait until "))
 361         {
 362                 string::size_type mod = s.find(" mod ", 11);
 363                 unsigned nondigit = (mod!=string::npos ? mod+5 : 11);
 364                 while(nondigit<s.size() && isdigit(s[nondigit]))
 365                         ++nondigit;
 366                 if(mod!=string::npos)
 367                 {
 368                         unsigned time = lexical_cast<unsigned>(s.substr(11, mod-11));
 369                         Row row(WAIT_UNTIL, time);
 370                         row.params.push_back(lexical_cast<unsigned>(s.substr(mod+5, nondigit-mod-5)));
 371                         return row;
 372                 }
 373                 else
 374                 {
 375                         unsigned time = lexical_cast<unsigned>(s.substr(11, nondigit-11));
 376                         Row row(WAIT_UNTIL, time);
 377                         row.params.push_back(3600);
 378                         return row;
 379                 }
 380         }
 381         else if(!s.compare(0, 10, "set speed "))
 382         {
 383                 unsigned nondigit = 11;
 384                 while(nondigit<s.size() && (isdigit(s[nondigit]) || s[nondigit]=='-'))
 385                         ++nondigit;
 386                 return Row(SPEED, lexical_cast<unsigned>(s.substr(10, nondigit-10)));
 387         }
 388         else if(s=="reverse")
 389                 return Row(REVERSE);
 390         else if(!s.compare(0, 10, "set route "))
 391         {
 392                 if(!s.compare(10, 3, "to "))
 393                 {
 394                         if(!s.compare(13, 7, "sensor "))
 395                                 return Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(20)));
 396                         else
 397                                 return Row(GOTO_ZONE, s.substr(13));
 398                 }
 399                 return Row(ROUTE, s.substr(10));
 400         }
 401
 402         throw invalid_argument("Timetable::Row::parse");
 403 }
 404
 405
 406 Timetable::Loader::Loader(Timetable &tt):
 407         DataFile::ObjectLoader<Timetable>(tt)
 408 {
 409         add("arrive",      &Loader::arrive);
 410         add("goto_sensor", &Loader::goto_sensor);
 411         add("goto_zone",   &Loader::goto_zone);
 412         add("route",       &Loader::route);
 413         add("speed",       &Loader::speed);
 414         add("reverse",     &Loader::reverse);
 415         add("travel_to",   &Loader::travel_to);
 416         add("travel_past", &Loader::travel_past);
 417         add("wait",        &Loader::wait);
 418         add("wait_train",  &Loader::wait_train);
 419         add("wait_until",  &Loader::wait_until);
 420
 421         // Deprecated alias
 422         add("goto",        &Loader::goto_sensor_str);
 423         add("travel",      &Loader::travel_to);
 424 }
 425
 426 void Timetable::Loader::arrive()
 427 {
 428         obj.rows.push_back(Row(ARRIVE));
 429 }
 430
 431 void Timetable::Loader::goto_sensor(unsigned s)
 432 {
 433         obj.rows.push_back(Row(GOTO_SENSOR, s));
 434 }
 435
 436 void Timetable::Loader::goto_sensor_str(const string &s)
 437 {
 438         if(!s.compare(0, 7, "sensor "))
 439                 obj.rows.push_back(Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(7))));
 440 }
 441
 442 void Timetable::Loader::goto_zone(const string &z)
 443 {
 444         obj.rows.push_back(Row(GOTO_ZONE, z));
 445 }
 446
 447 void Timetable::Loader::route(const string &r)
 448 {
 449         obj.rows.push_back(Row(ROUTE, r));
 450 }
 451
 452 void Timetable::Loader::reverse()
 453 {
 454         obj.rows.push_back(Row(REVERSE));
 455 }
 456
 457 void Timetable::Loader::speed(unsigned s)
 458 {
 459         obj.rows.push_back(Row(SPEED, s));
 460 }
 461
 462 void Timetable::Loader::travel_to(unsigned s)
 463 {
 464         obj.rows.push_back(Row(TRAVEL_TO, s));
 465 }
 466
 467 void Timetable::Loader::travel_past(unsigned s)
 468 {
 469         obj.rows.push_back(Row(TRAVEL_PAST, s));
 470 }
 471
 472 void Timetable::Loader::wait(unsigned t)
 473 {
 474         obj.rows.push_back(Row(WAIT_TIME, t));
 475 }
 476
 477 void Timetable::Loader::wait_train(unsigned t, unsigned s)
 478 {
 479         Row row(WAIT_TRAIN, t);
 480         row.params.push_back(s);
 481         obj.rows.push_back(row);
 482 }
 483
 484 void Timetable::Loader::wait_until(unsigned t, unsigned m)
 485 {
 486         Row row(WAIT_UNTIL, t);
 487         row.params.push_back(m);
 488         obj.rows.push_back(row);
 489 }
 490
 491 } // namespace R2C2