source/libr2c2/timetable.cpp

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