1 #include <msp/strings/format.h>
2 #include <msp/time/units.h>
8 #include "trackcircuit.h"
16 Timetable::Timetable(Train &t):
25 train.signal_advanced.connect(sigc::mem_fun(this, &Timetable::train_advanced));
26 train.signal_ai_event.connect(sigc::mem_fun(this, &Timetable::event));
27 Layout &layout = train.get_layout();
28 layout.signal_sensor_state_changed.connect(sigc::mem_fun(this, &Timetable::sensor_state_changed));
29 layout.signal_block_reserved.connect(sigc::mem_fun(this, &Timetable::block_reserved));
32 void Timetable::set_enabled(bool e)
37 void Timetable::reset()
40 wait_timeout = Time::TimeStamp();
45 void Timetable::clear()
51 void Timetable::append(const Row &row)
56 void Timetable::insert(unsigned i, const Row &row)
59 throw out_of_range("Timetable::insert");
61 rows.insert(rows.begin()+i, row);
66 const Timetable::Row &Timetable::get_row(unsigned i) const
69 throw out_of_range("Timetable::get_row");
73 void Timetable::tick(const Time::TimeStamp &t, const Time::TimeDelta &)
75 if(rows.empty() || !enabled)
78 if(wait_timeout && t>=wait_timeout)
80 wait_timeout = Time::TimeStamp();
81 current_row = (current_row+1)%rows.size();
87 Row &row = rows[current_row];
92 train.ai_message(Message("set-destination-block", &get_sensor(row.get_param<unsigned>(0))));
96 train.ai_message(Message("set-destination-zone", &get_zone(row.get_param<string>(0))));
100 Block *block = &get_sensor(row.get_param<unsigned>(0));
101 if(block->get_train()!=&train || block->get_sensor().get_state()<Sensor::MAYBE_ACTIVE)
103 pending_block = block;
104 pending_train = &train;
110 pending_block = &get_turnout(row.get_param<unsigned>(0)).get_block();
111 pending_train = (pending_block->get_train()==&train ? 0 : &train);
115 wait_timeout = t+row.get_param<unsigned>(0)*Time::sec;
120 unsigned unixtime = t.to_unixtime();
121 unsigned mod = row.get_param<unsigned>(1);
122 unsigned secs = ((mod+row.get_param<unsigned>(0))-(unixtime%mod))%mod;
123 wait_timeout = t+secs*Time::sec;
129 Train *other_train = &train.get_layout().get_train(row.get_param<unsigned>(0));
130 Block *block = &get_sensor(row.get_param<unsigned>(1));
131 if(block->get_train()!=other_train || block->get_sensor().get_state()<Sensor::MAYBE_ACTIVE)
133 pending_train = other_train;
134 pending_block = block;
147 float speed = row.get_param<unsigned>(0)/3.6*train.get_layout().get_catalogue().get_scale();
148 train.ai_message(Message("set-target-speed", speed));
152 train.ai_message(Message("toggle-reverse"));
155 train.ai_message(Message("set-route", &train.get_layout().get_route(row.get_param<string>(0))));
160 current_row = (current_row+1)%rows.size();
164 void Timetable::save(list<DataFile::Statement> &st) const
166 for(vector<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
167 st.push_back(i->save());
170 Block &Timetable::get_sensor(unsigned id)
172 return train.get_layout().get_block(id|0x1000);
175 Track &Timetable::get_turnout(unsigned id)
177 Block &block = train.get_layout().get_block(id|0x2000);
178 return **block.get_tracks().begin();
181 Zone &Timetable::get_zone(const string &name)
183 string::size_type space = name.rfind(' ');
184 if(space==string::npos || space==0)
185 throw invalid_argument("Timetable::get_zone");
186 unsigned number = lexical_cast<unsigned>(name.substr(space+1));
187 return train.get_layout().get_zone(name.substr(0, space), number);
190 void Timetable::sensor_state_changed(Sensor &sensor, Sensor::State state)
192 if(rows.empty() || !enabled)
196 if(TrackCircuit *tc = dynamic_cast<TrackCircuit *>(&sensor))
197 block = &tc->get_block();
201 if(block==pending_block && block->get_train()==pending_train && state>=Sensor::MAYBE_ACTIVE)
204 current_row = (current_row+1)%rows.size();
209 void Timetable::block_reserved(Block &block, Train *trn)
211 if(rows.empty() || !enabled)
214 if(&block==pending_block && trn==pending_train)
216 Row &row = rows[current_row];
217 if(row.type==TRAVEL_PAST && !pending_train)
220 current_row = (current_row+1)%rows.size();
226 void Timetable::train_advanced(Block &block)
228 if(rows.empty() || !enabled)
231 Row &row = rows[current_row];
232 if(row.type==TRAVEL_PAST && &block==pending_block && pending_train)
236 void Timetable::event(TrainAI &, const Message &ev)
238 if(ev.type=="arrived")
240 if(rows.empty() || !enabled)
243 Row &row = rows[current_row];
246 current_row = (current_row+1)%rows.size();
255 Timetable::Row::Row(RowType t):
260 Timetable::Row::Row(RowType t, const T &p):
267 const T &Timetable::Row::get_param(unsigned i) const
270 throw out_of_range("Timetable::Row::get_param");
271 return params[i].value<T>();
274 string Timetable::Row::str() const
279 return format("set route to sensor %d", get_param<unsigned>(0));
281 return "set route to "+get_param<string>(0);
283 return format("travel to sensor %d", get_param<unsigned>(0));
285 return format("travel past turnout %d", get_param<unsigned>(0));
287 return format("wait for %d seconds", get_param<unsigned>(0));
289 return format("wait until %d mod %d seconds", get_param<unsigned>(0), get_param<unsigned>(1));
291 return format("wait for train %d at sensor %d", get_param<unsigned>(0), get_param<unsigned>(1));
293 return "travel until arrival";
295 return format("set speed %d km/h", get_param<unsigned>(0));
299 return "set route "+get_param<string>(0);
301 return "invalid row";
305 DataFile::Statement Timetable::Row::save() const
310 return DataFile::Statement("goto_sensor"), get_param<unsigned>(0);
312 return DataFile::Statement("goto_zone"), get_param<string>(0);
314 return DataFile::Statement("travel_to"), get_param<unsigned>(0);
316 return DataFile::Statement("travel_past"), get_param<unsigned>(0);
318 return DataFile::Statement("wait"), get_param<unsigned>(0);
320 return DataFile::Statement("wait_until"), get_param<unsigned>(0), get_param<unsigned>(1);
322 return DataFile::Statement("wait_train"), get_param<unsigned>(0), get_param<unsigned>(1);
324 return DataFile::Statement("arrive");
326 return DataFile::Statement("speed"), get_param<unsigned>(0);
328 return DataFile::Statement("reverse");
330 return DataFile::Statement("route"), get_param<string>(0);
332 return DataFile::Statement();
336 Timetable::Row Timetable::Row::parse(const string &s)
338 if(!s.compare(0, 7, "travel "))
340 if(!s.compare(7, 10, "to sensor "))
341 return Row(TRAVEL_TO, lexical_cast<unsigned>(s.substr(17)));
342 else if(!s.compare(7, 13, "past turnout "))
343 return Row(TRAVEL_PAST, lexical_cast<unsigned>(s.substr(20)));
344 else if(!s.compare(7, string::npos, "until arrival"))
347 else if(!s.compare(0, 9, "wait for "))
351 unsigned nondigit = 10;
352 while(nondigit<s.size() && isdigit(s[nondigit]))
354 return Row(WAIT_TIME, lexical_cast<unsigned>(s.substr(9, nondigit-9)));
356 else if(!s.compare(9, 6, "train "))
358 string::size_type at = s.find(" at sensor ", 15);
361 Row row(WAIT_TRAIN, lexical_cast<unsigned>(s.substr(15, at-15)));
362 row.params.push_back(lexical_cast<unsigned>(s.substr(at+11)));
367 else if(!s.compare(0, 11, "wait until "))
369 string::size_type mod = s.find(" mod ", 11);
370 unsigned nondigit = (mod!=string::npos ? mod+5 : 11);
371 while(nondigit<s.size() && isdigit(s[nondigit]))
373 if(mod!=string::npos)
375 unsigned time = lexical_cast<unsigned>(s.substr(11, mod-11));
376 Row row(WAIT_UNTIL, time);
377 row.params.push_back(lexical_cast<unsigned>(s.substr(mod+5, nondigit-mod-5)));
382 unsigned time = lexical_cast<unsigned>(s.substr(11, nondigit-11));
383 Row row(WAIT_UNTIL, time);
384 row.params.push_back(3600);
388 else if(!s.compare(0, 10, "set speed "))
390 unsigned nondigit = 11;
391 while(nondigit<s.size() && (isdigit(s[nondigit]) || s[nondigit]=='-'))
393 return Row(SPEED, lexical_cast<unsigned>(s.substr(10, nondigit-10)));
395 else if(s=="reverse")
397 else if(!s.compare(0, 10, "set route "))
399 if(!s.compare(10, 3, "to "))
401 if(!s.compare(13, 7, "sensor "))
402 return Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(20)));
404 return Row(GOTO_ZONE, s.substr(13));
406 return Row(ROUTE, s.substr(10));
409 throw invalid_argument("Timetable::Row::parse");
413 Timetable::Loader::Loader(Timetable &tt):
414 DataFile::ObjectLoader<Timetable>(tt)
416 add("arrive", &Loader::arrive);
417 add("goto_sensor", &Loader::goto_sensor);
418 add("goto_zone", &Loader::goto_zone);
419 add("route", &Loader::route);
420 add("speed", &Loader::speed);
421 add("reverse", &Loader::reverse);
422 add("travel_to", &Loader::travel_to);
423 add("travel_past", &Loader::travel_past);
424 add("wait", &Loader::wait);
425 add("wait_train", &Loader::wait_train);
426 add("wait_until", &Loader::wait_until);
429 add("goto", &Loader::goto_sensor_str);
430 add("travel", &Loader::travel_to);
433 void Timetable::Loader::arrive()
435 obj.rows.push_back(Row(ARRIVE));
438 void Timetable::Loader::goto_sensor(unsigned s)
440 obj.rows.push_back(Row(GOTO_SENSOR, s));
443 void Timetable::Loader::goto_sensor_str(const string &s)
445 if(!s.compare(0, 7, "sensor "))
446 obj.rows.push_back(Row(GOTO_SENSOR, lexical_cast<unsigned>(s.substr(7))));
449 void Timetable::Loader::goto_zone(const string &z)
451 obj.rows.push_back(Row(GOTO_ZONE, z));
454 void Timetable::Loader::route(const string &r)
456 obj.rows.push_back(Row(ROUTE, r));
459 void Timetable::Loader::reverse()
461 obj.rows.push_back(Row(REVERSE));
464 void Timetable::Loader::speed(unsigned s)
466 obj.rows.push_back(Row(SPEED, s));
469 void Timetable::Loader::travel_to(unsigned s)
471 obj.rows.push_back(Row(TRAVEL_TO, s));
474 void Timetable::Loader::travel_past(unsigned s)
476 obj.rows.push_back(Row(TRAVEL_PAST, s));
479 void Timetable::Loader::wait(unsigned t)
481 obj.rows.push_back(Row(WAIT_TIME, t));
484 void Timetable::Loader::wait_train(unsigned t, unsigned s)
486 Row row(WAIT_TRAIN, t);
487 row.params.push_back(s);
488 obj.rows.push_back(row);
491 void Timetable::Loader::wait_until(unsigned t, unsigned m)
493 Row row(WAIT_UNTIL, t);
494 row.params.push_back(m);
495 obj.rows.push_back(row);