X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibmarklin%2Ftimetable.cpp;h=a699fc8c14b39cc51db86e64323a51e7a96fa654;hb=6ba6af3637c299ab00828c49de9151429488cc17;hp=cfe2ef6c0d6226eaec15ee2896c096f4372557a2;hpb=cf52013784607dc4d307bd1244c5346ee88336a4;p=r2c2.git diff --git a/source/libmarklin/timetable.cpp b/source/libmarklin/timetable.cpp index cfe2ef6..a699fc8 100644 --- a/source/libmarklin/timetable.cpp +++ b/source/libmarklin/timetable.cpp @@ -24,7 +24,8 @@ Timetable::Timetable(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)); @@ -35,10 +36,18 @@ 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(); - current_row = 0; + reset(); } void Timetable::append(const Row &row) @@ -75,28 +84,41 @@ void Timetable::tick(const Time::TimeStamp &t) 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(0)).get_tracks().begin())) + set_enabled(false); break; case TRAVEL: - pending_block = &parse_location(row.strparam); + pending_block = &parse_location(row.get_param(0)); + pending_train = &train; + executing = false; + break; + case WAIT_TIME: + wait_timeout = t+row.get_param(0)*Time::sec; executing = false; break; - case WAIT: - wait_timeout = t+row.intparam*Time::sec; + case WAIT_TRAIN: + pending_train = &train.get_layout().get_train(row.get_param(0)); + pending_block = &parse_location(row.get_param(1)); + executing = false; + break; + 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(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(0)))) + set_enabled(false); break; } @@ -108,26 +130,7 @@ void Timetable::tick(const Time::TimeStamp &t) void Timetable::save(list &st) const { for(vector::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) @@ -139,7 +142,7 @@ 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(); @@ -150,7 +153,7 @@ void Timetable::sensor_event(unsigned addr, bool state) 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; @@ -158,58 +161,119 @@ void Timetable::train_arrived() } -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 +Timetable::Row::Row(RowType t, const T &p): + type(t) +{ + params.push_back(p); +} + +template +const T &Timetable::Row::get_param(unsigned i) const +{ + if(i>=params.size()) + throw InvalidParameterValue("Parameter index out of range"); + return params[i].value(); +} string Timetable::Row::str() const { switch(type) { case GOTO: - return "go to "+strparam; + return "set route to "+get_param(0); case TRAVEL: - return "travel to "+strparam; - case WAIT: - return format("wait for %d seconds", intparam); + return "travel to "+get_param(0); + case WAIT_TIME: + return format("wait for %d seconds", get_param(0)); + case WAIT_TRAIN: + return format("wait for train %d at %s", get_param(0), get_param(1)); + case ARRIVE: + return "travel until arrival"; case SPEED: - return format("set speed %d km/h", intparam); + return format("set speed %d km/h", get_param(0)); + case REVERSE: + return "reverse"; case ROUTE: - return "set route "+strparam; + return "set route "+get_param(0); default: return "invalid row"; } } +DataFile::Statement Timetable::Row::save() const +{ + switch(type) + { + case GOTO: + return DataFile::Statement("goto"), get_param(0); + case TRAVEL: + return DataFile::Statement("travel"), get_param(0); + case WAIT_TIME: + return DataFile::Statement("wait"), get_param(0); + case WAIT_TRAIN: + return DataFile::Statement("wait_train"), get_param(0), get_param(1); + case ARRIVE: + return DataFile::Statement("arrive"); + case SPEED: + return DataFile::Statement("speed"), get_param(0); + case REVERSE: + return DataFile::Statement("reverse"); + case ROUTE: + return DataFile::Statement("route"), get_param(0); + default: + return DataFile::Statement(); + } +} + Timetable::Row Timetable::Row::parse(const string &s) { - if(!s.compare(0, 6, "go to ")) - return Row(GOTO, s.substr(6)); - else if(!s.compare(0, 10, "travel to ")) - return Row(TRAVEL, s.substr(10)); - else if(!s.compare(0, 9, "wait for ") && isdigit(s[9])) + if(!s.compare(0, 7, "travel ")) { - unsigned nondigit = 10; - while(nondigit(s.substr(9, nondigit-9))); + 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.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(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.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"); } @@ -218,11 +282,19 @@ Timetable::Row Timetable::Row::parse(const string &s) Timetable::Loader::Loader(Timetable &tt): DataFile::ObjectLoader(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) @@ -235,7 +307,12 @@ void Timetable::Loader::route(const string &r) 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)); } @@ -247,7 +324,14 @@ void Timetable::Loader::travel(const string &t) 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