2 #include <msp/strings/format.h>
8 #include "trainrouter.h"
16 Timetable::Timetable(Train &t):
18 current_row(rows.end()),
19 update_pending(false),
22 if(!train.get_ai_of_type<AIControl>())
24 if(!train.get_ai_of_type<TrainRouter>())
25 new TrainRouter(train);
27 train.signal_ai_event.connect(sigc::mem_fun(this, &Timetable::event));
28 train.get_layout().get_clock().signal_discontinuity.connect(sigc::mem_fun(this, &Timetable::clock_discontinuity));
31 void Timetable::append_row(const Row &r)
33 insert_row(rows.size(), r);
36 void Timetable::insert_row(unsigned i, const Row &r)
39 throw out_of_range("Timetable::insert_row");
41 list<Row>::iterator j = rows.begin();
43 j = rows.insert(j, r);
44 signal_row_added.emit(i, *j);
49 void Timetable::modify_row(unsigned i, const Row &r)
52 throw out_of_range("Timetable::remove_row");
54 list<Row>::iterator j = rows.begin();
57 signal_row_modified.emit(i, r);
62 void Timetable::remove_row(unsigned i)
65 throw out_of_range("Timetable::remove_row");
67 list<Row>::iterator j = rows.begin();
75 signal_row_removed.emit(i);
78 const Timetable::Row &Timetable::get_row(unsigned i) const
81 throw out_of_range("Timetable::get_row");
83 list<Row>::const_iterator j = rows.begin();
88 void Timetable::tick(const Time::TimeDelta &dt)
90 if(update_pending && !train.get_block_allocator().is_active())
93 if(current_row->type==DEPART)
95 const Clock &clock = train.get_layout().get_clock();
97 Time::TimeDelta t = clock.get_current_time();
98 if(t<current_row->time)
101 Time::TimeDelta b = t-dt*clock.get_rate();
102 if(b<current_row->time)
104 train.ai_message(Message("set-target-speed", train.get_maximum_speed()));
110 void Timetable::save(list<DataFile::Statement> &st) const
112 for(list<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
114 DataFile::Statement ss("row");
120 void Timetable::check_update(const list<Row>::const_iterator &i)
122 for(list<Row>::const_iterator j=current_row; (j!=rows.end() && j!=i); ++j)
125 update_pending = true;
128 list<Timetable::Row>::iterator Timetable::find_trip(const list<Row>::iterator &begin, list<Row>::iterator *arrive)
130 list<Row>::iterator i = find_if(begin, rows.end(), RowTypeMatch(DEPART));
134 list<Row>::iterator j = find_if(i, rows.end(), RowTypeMatch(ARRIVE));
143 void Timetable::update_route()
145 update_pending = false;
149 const Clock &clock = train.get_layout().get_clock();
153 sync_to_clock = false;
154 current_row = rows.begin();
155 for(list<Row>::iterator i=rows.begin(); i!=rows.end(); ++i)
156 if(i->type==DEPART && i->time>=clock.get_current_time())
163 list<Row>::iterator arrive;
164 list<Row>::iterator depart = find_trip(current_row, &arrive);
165 if(depart==rows.end())
167 depart = find_trip(rows.begin(), &arrive);
168 if(depart==rows.end())
170 current_row = rows.end();
175 train.ai_message(Message("clear-route"));
177 current_row = depart;
178 for(list<Row>::const_iterator i=depart; i!=rows.end(); ++i)
182 Time::TimeDelta dt = i->time-clock.get_current_time();
185 train.ai_message(Message("set-departure-delay", dt/clock.get_rate()));
189 train.ai_message(Message("add-waypoint", TrainRouter::Waypoint(*i->target, i->direction)));
195 list<Row>::iterator next_depart = find_trip(arrive, 0);
196 if(next_depart==rows.end())
197 next_depart = find_trip(rows.begin(), 0);
198 if(next_depart!=rows.end())
200 Time::TimeDelta dt = next_depart->time-depart->time;
201 while(dt<=Time::zero)
203 train.ai_message(Message("set-trip-duration", dt/clock.get_rate()));
207 void Timetable::event(TrainAI &, const Message &msg)
209 if(msg.type=="arrived")
211 if(current_row->type==ARRIVE)
213 update_pending = true;
215 else if(msg.type=="waypoint-reached")
217 const TrackChain *wp = msg.value.value<const TrackChain *>();
218 if(current_row->type==THROUGH && current_row->target==wp)
226 void Timetable::record_time()
228 current_row->time = train.get_layout().get_clock().get_current_time();
229 unsigned i = distance(rows.begin(), current_row);
230 signal_row_modified.emit(i, *current_row);
233 void Timetable::clock_discontinuity()
235 update_pending = true;
236 sync_to_clock = true;
240 Timetable::Row::Row():
243 direction(TrackChain::UNSPECIFIED)
246 void Timetable::Row::save(list<DataFile::Statement> &st) const
248 st.push_back((DataFile::Statement("type"), type));
249 st.push_back((DataFile::Statement("time"), time.raw()));
250 st.push_back(target->save_reference());
252 st.push_back((DataFile::Statement("direction"), direction));
256 Timetable::Loader::Loader(Timetable &t, Layout &l):
257 DataFile::ObjectLoader<Timetable>(t),
260 add("row", &Loader::row);
263 void Timetable::Loader::row()
267 obj.rows.push_back(r);
268 obj.update_pending = true;
272 Timetable::Row::Loader::Loader(Row &r, Layout &l):
273 DataFile::ObjectLoader<Timetable::Row>(r),
276 add("block", &Loader::block);
277 add("direction", &Row::direction);
278 add("time", &Loader::time);
279 add("type", &Row::type);
280 add("zone", &Loader::zone);
281 add("zone", &Loader::zone_numbered);
284 void Timetable::Row::Loader::block(unsigned id)
286 obj.target = &layout.get_block(id);
289 void Timetable::Row::Loader::time(Time::RawTime t)
291 obj.time = Time::TimeDelta(t);
294 void Timetable::Row::Loader::zone(const string &name)
296 zone_numbered(name, 0);
299 void Timetable::Row::Loader::zone_numbered(const string &name, unsigned number)
301 obj.target = &layout.get_zone(name, number);
305 void operator<<(LexicalConverter &conv, Timetable::RowType rt)
309 case Timetable::ARRIVE: conv.result("ARRIVE"); return;
310 case Timetable::DEPART: conv.result("DEPART"); return;
311 case Timetable::THROUGH: conv.result("THROUGH"); return;
312 default: throw lexical_error(format("conversion of RowType(%d) to string", rt));
316 void operator>>(const LexicalConverter &conv, Timetable::RowType &rt)
318 if(conv.get()=="ARRIVE")
319 rt = Timetable::ARRIVE;
320 else if(conv.get()=="DEPART")
321 rt = Timetable::DEPART;
322 else if(conv.get()=="THROUGH")
323 rt = Timetable::THROUGH;
325 throw lexical_error(format("conversion of '%s' to RowType", conv.get()));