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