X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibmarklin%2Ftimetable.cpp;h=f3d49c48fa1d44f0b38f8efe94d903c9dc664720;hb=29b131b59ba562f996a338a453745e5a4dfad5b7;hp=cfe2ef6c0d6226eaec15ee2896c096f4372557a2;hpb=cf52013784607dc4d307bd1244c5346ee88336a4;p=r2c2.git diff --git a/source/libmarklin/timetable.cpp b/source/libmarklin/timetable.cpp index cfe2ef6..f3d49c4 100644 --- a/source/libmarklin/timetable.cpp +++ b/source/libmarklin/timetable.cpp @@ -35,10 +35,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 +83,33 @@ 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; + train.go_to(**parse_location(row.get_param(0)).get_tracks().begin()); break; case TRAVEL: - pending_block = &parse_location(row.strparam); + pending_block = &parse_location(row.get_param(0)); executing = false; break; case WAIT: - wait_timeout = t+row.intparam*Time::sec; + wait_timeout = t+row.get_param(0)*Time::sec; + 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)); + train.set_route(&train.get_layout().get_route(row.get_param(0))); break; } @@ -108,26 +121,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) @@ -150,7 +144,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,42 +152,80 @@ 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; + return "travel to "+get_param(0); case WAIT: - return format("wait for %d seconds", intparam); + return format("wait for %d seconds", get_param(0)); + 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: + return DataFile::Statement("wait"), get_param(0); + 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)); + 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 ") && isdigit(s[9])) { unsigned nondigit = 10; @@ -204,12 +236,18 @@ Timetable::Row Timetable::Row::parse(const string &s) 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 +256,18 @@ 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); +} + +void Timetable::Loader::arrive() +{ + obj.rows.push_back(Row(ARRIVE)); } void Timetable::Loader::go_to(const string &t) @@ -235,7 +280,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)); }