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