source/libr2c2/timetable.cpp

   1 /* $Id$
   2
   3 This file is part of R²C²
   4 Copyright © 2010  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         train(t),
  24         enabled(false),
  25         current_row(0),
  26         executing(true),
  27         pending_block(0),
  28         pending_train(0)
  29 {
  30         train.signal_arrived.connect(sigc::mem_fun(this, &Timetable::train_arrived));
  31         train.get_layout().get_driver().signal_sensor.connect(sigc::mem_fun(this, &Timetable::sensor_event));
  32 }
  33
  34 void Timetable::set_enabled(bool e)
  35 {
  36         enabled = e;
  37 }
  38
  39 void Timetable::reset()
  40 {
  41         current_row = 0;
  42         wait_timeout = Time::TimeStamp();
  43         pending_block = 0;
  44         executing = true;
  45 }
  46
  47 void Timetable::clear()
  48 {
  49         rows.clear();
  50         reset();
  51 }
  52
  53 void Timetable::append(const Row &row)
  54 {
  55         rows.push_back(row);
  56 }
  57
  58 void Timetable::insert(unsigned i, const Row &row)
  59 {
  60         if(i>rows.size())
  61                 throw InvalidParameterValue("Insert position out of range");
  62
  63         rows.insert(rows.begin()+i, row);
  64         if(i<=current_row)
  65                 ++current_row;
  66 }
  67
  68 const Timetable::Row &Timetable::get_row(unsigned i) const
  69 {
  70         if(i>=rows.size())
  71                 throw InvalidParameterValue("Row index out of range");
  72         return rows[i];
  73 }
  74
  75 void Timetable::tick(const Time::TimeStamp &t)
  76 {
  77         if(rows.empty() || !enabled)
  78                 return;
  79
  80         if(wait_timeout && t>=wait_timeout)
  81         {
  82                 wait_timeout = Time::TimeStamp();
  83                 current_row = (current_row+1)%rows.size();
  84                 executing = true;
  85         }
  86
  87         if(executing)
  88         {
  89                 Row &row = rows[current_row];
  90                 switch(row.type)
  91                 {
  92                 case GOTO_SENSOR:
  93                         if(!train.go_to(get_sensor(row.get_param<unsigned>(0))))
  94                                 set_enabled(false);
  95                         break;
  96                 case GOTO_ZONE:
  97                         if(!train.go_to(get_zone(row.get_param<string>(0))))
  98                                 set_enabled(false);
  99                         break;
 100                 case TRAVEL:
 101                         pending_block = &get_sensor(row.get_param<unsigned>(0)).get_block();
 102                         pending_train = &train;
 103                         executing = false;
 104                         break;
 105                 case WAIT_TIME:
 106                         wait_timeout = t+row.get_param<unsigned>(0)*Time::sec;
 107                         executing = false;
 108                         break;
 109                 case WAIT_UNTIL:
 110                         {
 111                                 unsigned unixtime = t.to_unixtime();
 112                                 unsigned mod = row.get_param<unsigned>(1);
 113                                 unsigned secs = ((mod+row.get_param<unsigned>(0))-(unixtime%mod))%mod;
 114                                 wait_timeout = t+secs*Time::sec;
 115                                 executing = false;
 116                         }
 117                         break;
 118                 case WAIT_TRAIN:
 119                         pending_train = &train.get_layout().get_train(row.get_param<unsigned>(0));
 120                         pending_block = &get_sensor(row.get_param<unsigned>(1)).get_block();
 121                         executing = false;
 122                         break;
 123                 case ARRIVE:
 124                         executing = false;
 125                         break;
 126                 case SPEED:
 127                         train.set_control("speed", row.get_param<unsigned>(0)/3.6*train.get_layout().get_catalogue().get_scale());
 128                         break;
 129                 case REVERSE:
 130                         train.set_control("reverse", !train.get_control("reverse"));
 131                         break;
 132                 case ROUTE:
 133                         if(!train.set_route(&train.get_layout().get_route(row.get_param<string>(0))))
 134                                 set_enabled(false);
 135                         break;
 136                 }
 137
 138                 if(executing)
 139                         current_row = (current_row+1)%rows.size();
 140         }
 141 }
 142
 143 void Timetable::save(list<DataFile::Statement> &st) const
 144 {
 145         for(vector<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
 146                 st.push_back(i->save());
 147 }
 148
 149 Track &Timetable::get_sensor(unsigned id)
 150 {
 151         Block &block = train.get_layout().get_block(id|0x1000);
 152         return **block.get_tracks().begin();
 153 }
 154
 155 Zone &Timetable::get_zone(const string &name)
 156 {
 157         string::size_type space = name.rfind(' ');
 158         if(space==string::npos || space==0)
 159                 throw InvalidParameterValue("Invalid zone name");
 160         unsigned number = lexical_cast<unsigned>(name.substr(space+1));
 161         return train.get_layout().get_zone(name.substr(0, space), number);
 162 }
 163
 164 void Timetable::sensor_event(unsigned addr, bool state)
 165 {
 166         if(pending_block && pending_block->get_train()==pending_train && addr==pending_block->get_sensor_id() && state)
 167         {
 168                 pending_block = 0;
 169                 current_row = (current_row+1)%rows.size();
 170                 executing = true;
 171         }
 172 }
 173
 174 void Timetable::train_arrived()
 175 {
 176         Row &row = rows[current_row];
 177         if(row.type==ARRIVE)
 178         {
 179                 current_row = (current_row+1)%rows.size();
 180                 executing = true;
 181         }
 182 }
 183
 184
 185 Timetable::Row::Row(RowType t):
 186         type(t)
 187 { }
 188
 189 template<typename T>
 190 Timetable::Row::Row(RowType t, const T &p):
 191         type(t)
 192 {
 193         params.push_back(p);
 194 }
 195
 196 template<typename T>
 197 const T &Timetable::Row::get_param(unsigned i) const
 198 {
 199         if(i>=params.size())
 200                 throw InvalidParameterValue("Parameter index out of range");
 201         return params[i].value<T>();
 202 }
 203
 204 string Timetable::Row::str() const
 205 {
 206         switch(type)
 207         {
 208         case GOTO_SENSOR:
 209                 return "set route to sensor "+get_param<unsigned>(0);
 210         case GOTO_ZONE:
 211                 return "set route to "+get_param<string>(0);
 212         case TRAVEL:
 213                 return "travel to "+get_param<string>(0);
 214         case WAIT_TIME:
 215                 return format("wait for %d seconds", get_param<unsigned>(0));
 216         case WAIT_UNTIL:
 217                 return format("wait until %d mod %d seconds", get_param<unsigned>(0), get_param<unsigned>(1));
 218         case WAIT_TRAIN:
 219                 return format("wait for train %d at %s", get_param<unsigned>(0), get_param<string>(1));
 220         case ARRIVE:
 221                 return "travel until arrival";
 222         case SPEED:
 223                 return format("set speed %d km/h", get_param<unsigned>(0));
 224         case REVERSE:
 225                 return "reverse";
 226         case ROUTE:
 227                 return "set route "+get_param<string>(0);
 228         default:
 229                 return "invalid row";
 230         }
 231 }
 232
 233 DataFile::Statement Timetable::Row::save() const
 234 {
 235         switch(type)
 236         {
 237         case GOTO_SENSOR:
 238                 return DataFile::Statement("goto_sensor"), get_param<unsigned>(0);
 239         case GOTO_ZONE:
 240                 return DataFile::Statement("goto_zone"), get_param<string>(0);
 241         case TRAVEL:
 242                 return DataFile::Statement("travel"), get_param<string>(0);
 243         case WAIT_TIME:
 244                 return DataFile::Statement("wait"), get_param<unsigned>(0);
 245         case WAIT_UNTIL:
 246                 return DataFile::Statement("wait_until"), get_param<unsigned>(0), get_param<unsigned>(1);
 247         case WAIT_TRAIN:
 248                 return DataFile::Statement("wait_train"), get_param<unsigned>(0), get_param<unsigned>(1);
 249         case ARRIVE:
 250                 return DataFile::Statement("arrive");
 251         case SPEED:
 252                 return DataFile::Statement("speed"), get_param<unsigned>(0);
 253         case REVERSE:
 254                 return DataFile::Statement("reverse");
 255         case ROUTE:
 256                 return DataFile::Statement("route"), get_param<string>(0);
 257         default:
 258                 return DataFile::Statement();
 259         }
 260 }
 261
 262 Timetable::Row Timetable::Row::parse(const string &s)
 263 {
 264         if(!s.compare(0, 7, "travel "))
 265         {
 266                 if(!s.compare(7, 10, "to sensor "))
 267                         return Row(TRAVEL, lexical_cast<unsigned>(s.substr(17)));
 268                 else if(!s.compare(7, string::npos, "until arrival"))
 269                         return Row(ARRIVE);
 270         }
 271         else if(!s.compare(0, 9, "wait for "))
 272         {
 273                 if(isdigit(s[9]))
 274                 {
 275                         unsigned nondigit = 10;
 276                         while(nondigit<s.size() && isdigit(s[nondigit]))
 277                                 ++nondigit;
 278                         return Row(WAIT_TIME, lexical_cast<unsigned>(s.substr(9, nondigit-9)));
 279                 }
 280                 else if(!s.compare(9, 6, "train "))
 281                 {
 282                         string::size_type at = s.find(" at sensor ", 15);
 283                         if(at!=string::npos)
 284                         {
 285                                 Row row(WAIT_TRAIN, lexical_cast<unsigned>(s.substr(15, at-15)));
 286                                 row.params.push_back(lexical_cast<unsigned>(s.substr(at+11)));
 287                                 return row;
 288                         }
 289                 }
 290         }
 291         else if(!s.compare(0, 11, "wait until "))
 292         {
 293                 string::size_type mod = s.find(" mod ", 11);
 294                 unsigned nondigit = (mod!=string::npos ? mod+5 : 11);
 295                 while(nondigit<s.size() && isdigit(s[nondigit]))
 296                         ++nondigit;
 297                 if(mod!=string::npos)
 298                 {
 299                         unsigned time = lexical_cast<unsigned>(s.substr(11, mod-11));
 300                         Row row(WAIT_UNTIL, time);
 301                         row.params.push_back(lexical_cast<unsigned>(s.substr(mod+5, nondigit-mod-5)));
 302                         return row;
 303                 }
 304                 else
 305                 {
 306                         unsigned time = lexical_cast<unsigned>(s.substr(11, nondigit-11));
 307                         Row row(WAIT_UNTIL, time);
 308                         row.params.push_back(3600);
 309                         return row;
 310                 }
 311         }
 312         else if(!s.compare(0, 10, "set speed "))
 313         {
 314                 unsigned nondigit = 11;
 315                 while(nondigit<s.size() && (isdigit(s[nondigit]) || s[nondigit]=='-'))
 316                         ++nondigit;
 317                 return Row(SPEED, lexical_cast<unsigned>(s.substr(10, nondigit-10)));
 318         }
 319         else if(s=="reverse")
 320                 return Row(REVERSE);
 321         else if(!s.compare(0, 10, "set route "))
 322         {
 323                 if(!s.compare(10, 3, "to "))
 324                 {
 325                         if(!s.compare(13, 7, "sensor "))
 326                                 return Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(20)));
 327                         else
 328                                 return Row(GOTO_ZONE, s.substr(13));
 329                 }
 330                 return Row(ROUTE, s.substr(10));
 331         }
 332
 333         throw InvalidParameterValue("Invalid row");
 334 }
 335
 336
 337 Timetable::Loader::Loader(Timetable &tt):
 338         DataFile::ObjectLoader<Timetable>(tt)
 339 {
 340         add("arrive",      &Loader::arrive);
 341         add("goto_sensor", static_cast<void (Loader::*)(unsigned)>(&Loader::goto_sensor));
 342         add("goto_zone",   &Loader::goto_zone);
 343         add("route",       &Loader::route);
 344         add("speed",       &Loader::speed);
 345         add("reverse",     &Loader::reverse);
 346         add("travel",      &Loader::travel);
 347         add("wait",        &Loader::wait);
 348         add("wait_train",  &Loader::wait_train);
 349         add("wait_until",  &Loader::wait_until);
 350
 351         // Deprecated alias
 352         add("goto",        static_cast<void (Loader::*)(const string &)>(&Loader::goto_sensor));
 353 }
 354
 355 void Timetable::Loader::arrive()
 356 {
 357         obj.rows.push_back(Row(ARRIVE));
 358 }
 359
 360 void Timetable::Loader::goto_sensor(unsigned s)
 361 {
 362         obj.rows.push_back(Row(GOTO_SENSOR, s));
 363 }
 364
 365 void Timetable::Loader::goto_sensor(const string &s)
 366 {
 367         if(!s.compare(0, 7, "sensor "))
 368                 obj.rows.push_back(Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(7))));
 369 }
 370
 371 void Timetable::Loader::goto_zone(const string &z)
 372 {
 373         obj.rows.push_back(Row(GOTO_ZONE, z));
 374 }
 375
 376 void Timetable::Loader::route(const string &r)
 377 {
 378         obj.rows.push_back(Row(ROUTE, r));
 379 }
 380
 381 void Timetable::Loader::reverse()
 382 {
 383         obj.rows.push_back(Row(REVERSE));
 384 }
 385
 386 void Timetable::Loader::speed(unsigned s)
 387 {
 388         obj.rows.push_back(Row(SPEED, s));
 389 }
 390
 391 void Timetable::Loader::travel(const string &t)
 392 {
 393         obj.rows.push_back(Row(TRAVEL, t));
 394 }
 395
 396 void Timetable::Loader::wait(unsigned t)
 397 {
 398         obj.rows.push_back(Row(WAIT_TIME, t));
 399 }
 400
 401 void Timetable::Loader::wait_train(unsigned t, unsigned s)
 402 {
 403         Row row(WAIT_TRAIN, t);
 404         row.params.push_back(s);
 405         obj.rows.push_back(row);
 406 }
 407
 408 void Timetable::Loader::wait_until(unsigned t, unsigned m)
 409 {
 410         Row row(WAIT_UNTIL, t);
 411         row.params.push_back(m);
 412         obj.rows.push_back(row);
 413 }
 414
 415 } // namespace R2C2