source/libr2c2/timetable.cpp

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