Distributed under the GPL
*/
+#include <msp/strings/formatter.h>
#include <msp/time/units.h>
#include "block.h"
#include "catalogue.h"
Timetable::Timetable(Train &t):
train(t),
+ enabled(false),
current_row(0),
executing(true),
- pending_block(0)
+ pending_block(0),
+ pending_train(0)
{
train.signal_arrived.connect(sigc::mem_fun(this, &Timetable::train_arrived));
train.get_layout().get_driver().signal_sensor.connect(sigc::mem_fun(this, &Timetable::sensor_event));
}
+void Timetable::set_enabled(bool e)
+{
+ enabled = e;
+}
+
+void Timetable::reset()
+{
+ current_row = 0;
+ wait_timeout = Time::TimeStamp();
+ pending_block = 0;
+ executing = true;
+}
+
+void Timetable::clear()
+{
+ rows.clear();
+ reset();
+}
+
+void Timetable::append(const Row &row)
+{
+ rows.push_back(row);
+}
+
+void Timetable::insert(unsigned i, const Row &row)
+{
+ if(i>rows.size())
+ throw InvalidParameterValue("Insert position out of range");
+
+ rows.insert(rows.begin()+i, row);
+ if(i<=current_row)
+ ++current_row;
+}
+
+const Timetable::Row &Timetable::get_row(unsigned i) const
+{
+ if(i>=rows.size())
+ throw InvalidParameterValue("Row index out of range");
+ return rows[i];
+}
+
void Timetable::tick(const Time::TimeStamp &t)
{
+ if(rows.empty() || !enabled)
+ return;
+
if(wait_timeout && t>=wait_timeout)
{
wait_timeout = Time::TimeStamp();
executing = true;
}
- while(executing)
+ if(executing)
{
Row &row = rows[current_row];
switch(row.type)
{
case GOTO:
- train.go_to(**parse_location(row.strparam).get_tracks().begin());
- executing = false;
+ if(!train.go_to(**parse_location(row.get_param<string>(0)).get_tracks().begin()))
+ set_enabled(false);
break;
case TRAVEL:
- pending_block = &parse_location(row.strparam);
+ pending_block = &parse_location(row.get_param<string>(0));
+ pending_train = &train;
+ executing = false;
+ break;
+ case WAIT_TIME:
+ wait_timeout = t+row.get_param<unsigned>(0)*Time::sec;
+ executing = false;
+ break;
+ case WAIT_TRAIN:
+ pending_train = &train.get_layout().get_train(row.get_param<unsigned>(0));
+ pending_block = &parse_location(row.get_param<string>(1));
executing = false;
break;
- case WAIT:
- wait_timeout = t+row.intparam*Time::sec;
+ case ARRIVE:
executing = false;
break;
case SPEED:
- train.set_control("speed", row.intparam/3.6*train.get_layout().get_catalogue().get_scale());
+ train.set_control("speed", row.get_param<unsigned>(0)/3.6*train.get_layout().get_catalogue().get_scale());
+ break;
+ case REVERSE:
+ train.set_control("reverse", !train.get_control("reverse"));
break;
case ROUTE:
- train.set_route(&train.get_layout().get_route(row.strparam));
+ if(!train.set_route(&train.get_layout().get_route(row.get_param<string>(0))))
+ set_enabled(false);
break;
}
void Timetable::save(list<DataFile::Statement> &st) const
{
for(vector<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
- {
- switch(i->type)
- {
- case GOTO:
- st.push_back((DataFile::Statement("goto"), i->strparam));
- break;
- case TRAVEL:
- st.push_back((DataFile::Statement("travel"), i->strparam));
- break;
- case WAIT:
- st.push_back((DataFile::Statement("wait"), i->intparam));
- break;
- case SPEED:
- st.push_back((DataFile::Statement("speed"), i->intparam));
- break;
- case ROUTE:
- st.push_back((DataFile::Statement("route"), i->strparam));
- break;
- }
- }
+ st.push_back(i->save());
}
Block &Timetable::parse_location(const string &loc)
void Timetable::sensor_event(unsigned addr, bool state)
{
- if(pending_block && pending_block->get_train()==&train && addr==pending_block->get_sensor_id() && state)
+ if(pending_block && pending_block->get_train()==pending_train && addr==pending_block->get_sensor_id() && state)
{
pending_block = 0;
current_row = (current_row+1)%rows.size();
void Timetable::train_arrived()
{
Row &row = rows[current_row];
- if(row.type==GOTO)
+ if(row.type==ARRIVE)
{
current_row = (current_row+1)%rows.size();
executing = true;
}
-Timetable::Row::Row(RowType t, int p):
- type(t),
- intparam(p)
+Timetable::Row::Row(RowType t):
+ type(t)
{ }
-Timetable::Row::Row(RowType t, const string &p):
- type(t),
- intparam(0),
- strparam(p)
-{ }
+template<typename T>
+Timetable::Row::Row(RowType t, const T &p):
+ type(t)
+{
+ params.push_back(p);
+}
+
+template<typename T>
+const T &Timetable::Row::get_param(unsigned i) const
+{
+ if(i>=params.size())
+ throw InvalidParameterValue("Parameter index out of range");
+ return params[i].value<T>();
+}
+
+string Timetable::Row::str() const
+{
+ switch(type)
+ {
+ case GOTO:
+ return "set route to "+get_param<string>(0);
+ case TRAVEL:
+ return "travel to "+get_param<string>(0);
+ case WAIT_TIME:
+ return format("wait for %d seconds", get_param<unsigned>(0));
+ case WAIT_TRAIN:
+ return format("wait for train %d at %s", get_param<unsigned>(0), get_param<string>(1));
+ case ARRIVE:
+ return "travel until arrival";
+ case SPEED:
+ return format("set speed %d km/h", get_param<unsigned>(0));
+ case REVERSE:
+ return "reverse";
+ case ROUTE:
+ return "set route "+get_param<string>(0);
+ default:
+ return "invalid row";
+ }
+}
+
+DataFile::Statement Timetable::Row::save() const
+{
+ switch(type)
+ {
+ case GOTO:
+ return DataFile::Statement("goto"), get_param<string>(0);
+ case TRAVEL:
+ return DataFile::Statement("travel"), get_param<string>(0);
+ case WAIT_TIME:
+ return DataFile::Statement("wait"), get_param<unsigned>(0);
+ case WAIT_TRAIN:
+ return DataFile::Statement("wait_train"), get_param<unsigned>(0), get_param<string>(1);
+ case ARRIVE:
+ return DataFile::Statement("arrive");
+ case SPEED:
+ return DataFile::Statement("speed"), get_param<unsigned>(0);
+ case REVERSE:
+ return DataFile::Statement("reverse");
+ case ROUTE:
+ return DataFile::Statement("route"), get_param<string>(0);
+ default:
+ return DataFile::Statement();
+ }
+}
+
+Timetable::Row Timetable::Row::parse(const string &s)
+{
+ if(!s.compare(0, 7, "travel "))
+ {
+ if(!s.compare(7, 3, "to "))
+ return Row(TRAVEL, s.substr(10));
+ else if(!s.compare(7, string::npos, "until arrival"))
+ return Row(ARRIVE);
+ }
+ else if(!s.compare(0, 9, "wait for "))
+ {
+ if(isdigit(s[9]))
+ {
+ unsigned nondigit = 10;
+ while(nondigit<s.size() && isdigit(s[nondigit]))
+ ++nondigit;
+ return Row(WAIT_TIME, lexical_cast<unsigned>(s.substr(9, nondigit-9)));
+ }
+ else if(!s.compare(9, 6, "train "))
+ {
+ string::size_type at = s.find(" at ", 15);
+ if(at!=string::npos)
+ {
+ Row row(WAIT_TRAIN, lexical_cast<unsigned>(s.substr(15, at-15)));
+ row.params.push_back(s.substr(at+4));
+ return row;
+ }
+ }
+ }
+ else if(!s.compare(0, 10, "set speed "))
+ {
+ unsigned nondigit = 11;
+ while(nondigit<s.size() && (isdigit(s[nondigit]) || s[nondigit]=='-'))
+ ++nondigit;
+ return Row(SPEED, lexical_cast<unsigned>(s.substr(10, nondigit-10)));
+ }
+ else if(s=="reverse")
+ return Row(REVERSE);
+ else if(!s.compare(0, 10, "set route "))
+ {
+ if(!s.compare(10, 3, "to "))
+ return Row(GOTO, s.substr(13));
+ return Row(ROUTE, s.substr(10));
+ }
+
+ throw InvalidParameterValue("Invalid row");
+}
Timetable::Loader::Loader(Timetable &tt):
DataFile::ObjectLoader<Timetable>(tt)
{
- add("goto", &Loader::go_to);
- add("route", &Loader::route);
- add("speed", &Loader::speed);
- add("travel", &Loader::travel);
- add("wait", &Loader::wait);
+ add("arrive", &Loader::arrive);
+ add("goto", &Loader::go_to);
+ add("route", &Loader::route);
+ add("speed", &Loader::speed);
+ add("reverse", &Loader::reverse);
+ add("travel", &Loader::travel);
+ add("wait", &Loader::wait);
+ add("wait_train", &Loader::wait_train);
+}
+
+void Timetable::Loader::arrive()
+{
+ obj.rows.push_back(Row(ARRIVE));
}
void Timetable::Loader::go_to(const string &t)
obj.rows.push_back(Row(ROUTE, r));
}
-void Timetable::Loader::speed(int s)
+void Timetable::Loader::reverse()
+{
+ obj.rows.push_back(Row(REVERSE));
+}
+
+void Timetable::Loader::speed(unsigned s)
{
obj.rows.push_back(Row(SPEED, s));
}
void Timetable::Loader::wait(unsigned t)
{
- obj.rows.push_back(Row(WAIT, t));
+ obj.rows.push_back(Row(WAIT_TIME, t));
+}
+
+void Timetable::Loader::wait_train(unsigned t, const string &b)
+{
+ Row row(WAIT_TRAIN, t);
+ row.params.push_back(b);
+ obj.rows.push_back(row);
}
} // namespace Marklin
projects / r2c2.git / blobdiff