source/libr2c2/timetable.cpp

   1 #include <algorithm>
   2 #include <msp/strings/format.h>
   3 #include "aicontrol.h"
   4 #include "clock.h"
   5 #include "layout.h"
   6 #include "timetable.h"
   7 #include "train.h"
   8 #include "trainrouter.h"
   9 #include "zone.h"
  10
  11 using namespace std;
  12 using namespace Msp;
  13
  14 namespace R2C2 {
  15
  16 Timetable::Timetable(Train &t):
  17         TrainAI(t),
  18         current_row(rows.end()),
  19         update_pending(false),
  20         sync_to_clock(true)
  21 {
  22         if(!train.get_ai_of_type<AIControl>())
  23                 new AIControl(train);
  24         if(!train.get_ai_of_type<TrainRouter>())
  25                 new TrainRouter(train);
  26
  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));
  29 }
  30
  31 void Timetable::append_row(const Row &r)
  32 {
  33         insert_row(rows.size(), r);
  34 }
  35
  36 void Timetable::insert_row(unsigned i, const Row &r)
  37 {
  38         if(i>rows.size())
  39                 throw out_of_range("Timetable::insert_row");
  40
  41         list<Row>::iterator j = rows.begin();
  42         advance(j, i);
  43         j = rows.insert(j, r);
  44         signal_row_added.emit(i, *j);
  45
  46         check_update(j);
  47 }
  48
  49 void Timetable::modify_row(unsigned i, const Row &r)
  50 {
  51         if(i>=rows.size())
  52                 throw out_of_range("Timetable::remove_row");
  53
  54         list<Row>::iterator j = rows.begin();
  55         advance(j, i);
  56         *j = r;
  57         signal_row_modified.emit(i, r);
  58
  59         check_update(j);
  60 }
  61
  62 void Timetable::remove_row(unsigned i)
  63 {
  64         if(i>=rows.size())
  65                 throw out_of_range("Timetable::remove_row");
  66
  67         list<Row>::iterator j = rows.begin();
  68         advance(j, i);
  69
  70         check_update(j);
  71         if(j==current_row)
  72                 --current_row;
  73
  74         rows.erase(j);
  75         signal_row_removed.emit(i);
  76 }
  77
  78 const Timetable::Row &Timetable::get_row(unsigned i) const
  79 {
  80         if(i>=rows.size())
  81                 throw out_of_range("Timetable::get_row");
  82
  83         list<Row>::const_iterator j = rows.begin();
  84         advance(j, i);
  85         return *j;
  86 }
  87
  88 void Timetable::tick(const Time::TimeDelta &dt)
  89 {
  90         if(update_pending && !train.get_block_allocator().is_active())
  91                 update_route();
  92 }
  93
  94 void Timetable::save(list<DataFile::Statement> &st) const
  95 {
  96         for(list<Row>::const_iterator i=rows.begin(); i!=rows.end(); ++i)
  97         {
  98                 DataFile::Statement ss("row");
  99                 i->save(ss.sub);
 100                 st.push_back(ss);
 101         }
 102 }
 103
 104 void Timetable::check_update(const list<Row>::const_iterator &i)
 105 {
 106         for(list<Row>::const_iterator j=current_row; (j!=rows.end() && j!=i); ++j)
 107                 if(j->type==ARRIVE)
 108                         return;
 109         update_pending = true;
 110 }
 111
 112 list<Timetable::Row>::iterator Timetable::find_trip(const list<Row>::iterator &begin, list<Row>::iterator *arrive)
 113 {
 114         list<Row>::iterator i = find_if(begin, rows.end(), RowTypeMatch(DEPART));
 115         if(i==rows.end())
 116                 return i;
 117
 118         list<Row>::iterator j = find_if(i, rows.end(), RowTypeMatch(ARRIVE));
 119         if(j==rows.end())
 120                 return j;
 121
 122         if(arrive)
 123                 *arrive = j;
 124         return i;
 125 }
 126
 127 void Timetable::update_route()
 128 {
 129         update_pending = false;
 130         if(rows.empty())
 131                 return;
 132
 133         const Clock &clock = train.get_layout().get_clock();
 134
 135         if(sync_to_clock)
 136         {
 137                 sync_to_clock = false;
 138                 current_row = rows.begin();
 139                 for(list<Row>::iterator i=rows.begin(); i!=rows.end(); ++i)
 140                         if(i->type==DEPART && i->time>=clock.get_current_time())
 141                         {
 142                                 current_row = i;
 143                                 break;
 144                         }
 145         }
 146
 147         list<Row>::iterator arrive;
 148         list<Row>::iterator depart = find_trip(current_row, &arrive);
 149         if(depart==rows.end())
 150         {
 151                 depart = find_trip(rows.begin(), &arrive);
 152                 if(depart==rows.end())
 153                 {
 154                         current_row = rows.end();
 155                         return;
 156                 }
 157         }
 158
 159         train.ai_message(Message("clear-route"));
 160
 161         current_row = depart;
 162         for(list<Row>::const_iterator i=depart; i!=rows.end(); ++i)
 163         {
 164                 if(i->type==DEPART)
 165                 {
 166                         Time::TimeDelta dt = i->time-clock.get_current_time();
 167                         while(dt<Time::zero)
 168                                 dt += Time::day;
 169                         train.ai_message(Message("set-departure-delay", dt/clock.get_rate()));
 170                 }
 171                 else
 172                 {
 173                         train.ai_message(Message("add-waypoint", TrainRouter::Waypoint(*i->target, i->direction)));
 174                         if(i->type==ARRIVE)
 175                                 break;
 176                 }
 177         }
 178
 179         list<Row>::iterator next_depart = find_trip(arrive, 0);
 180         if(next_depart==rows.end())
 181                 next_depart = find_trip(rows.begin(), 0);
 182         if(next_depart!=rows.end())
 183         {
 184                 Time::TimeDelta dt = next_depart->time-depart->time;
 185                 while(dt<=Time::zero)
 186                         dt += Time::day;
 187                 train.ai_message(Message("set-trip-duration", dt/clock.get_rate()));
 188         }
 189
 190         late_arrival = false;
 191 }
 192
 193 void Timetable::event(TrainAI &, const Message &msg)
 194 {
 195         if(msg.type=="departed")
 196         {
 197                 if(current_row->type==DEPART)
 198                         ++current_row;
 199         }
 200         else if(msg.type=="arrived")
 201         {
 202                 if(current_row->type==ARRIVE)
 203                         record_time();
 204                 update_pending = true;
 205         }
 206         else if(msg.type=="waypoint-reached")
 207         {
 208                 const TrackChain *wp = msg.value.value<const TrackChain *>();
 209                 if(current_row->type==THROUGH && current_row->target==wp)
 210                 {
 211                         record_time();
 212                         ++current_row;
 213                 }
 214         }
 215 }
 216
 217 void Timetable::record_time()
 218 {
 219         current_row->time = train.get_layout().get_clock().get_current_time();
 220         unsigned i = distance(rows.begin(), current_row);
 221         signal_row_modified.emit(i, *current_row);
 222 }
 223
 224 void Timetable::clock_discontinuity()
 225 {
 226         update_pending = true;
 227         sync_to_clock = true;
 228 }
 229
 230
 231 Timetable::Row::Row():
 232         type(ARRIVE),
 233         target(0),
 234         direction(TrackChain::UNSPECIFIED)
 235 { }
 236
 237 void Timetable::Row::save(list<DataFile::Statement> &st) const
 238 {
 239         st.push_back((DataFile::Statement("type"), type));
 240         st.push_back((DataFile::Statement("time"), time.raw()));
 241         st.push_back(target->save_reference());
 242         if(direction)
 243                 st.push_back((DataFile::Statement("direction"), direction));
 244 }
 245
 246
 247 Timetable::Loader::Loader(Timetable &t, Layout &l):
 248         DataFile::ObjectLoader<Timetable>(t),
 249         layout(l)
 250 {
 251         add("row", &Loader::row);
 252 }
 253
 254 void Timetable::Loader::row()
 255 {
 256         Row r;
 257         load_sub(r, layout);
 258         obj.rows.push_back(r);
 259         obj.update_pending = true;
 260 }
 261
 262
 263 Timetable::Row::Loader::Loader(Row &r, Layout &l):
 264         DataFile::ObjectLoader<Timetable::Row>(r),
 265         layout(l)
 266 {
 267         add("block", &Loader::block);
 268         add("direction", &Row::direction);
 269         add("time", &Loader::time);
 270         add("type", &Row::type);
 271         add("zone", &Loader::zone);
 272         add("zone", &Loader::zone_numbered);
 273 }
 274
 275 void Timetable::Row::Loader::block(unsigned id)
 276 {
 277         obj.target = &layout.get_block(id);
 278 }
 279
 280 void Timetable::Row::Loader::time(Time::RawTime t)
 281 {
 282         obj.time = Time::TimeDelta(t);
 283 }
 284
 285 void Timetable::Row::Loader::zone(const string &name)
 286 {
 287         zone_numbered(name, 0);
 288 }
 289
 290 void Timetable::Row::Loader::zone_numbered(const string &name, unsigned number)
 291 {
 292         obj.target = &layout.get_zone(name, number);
 293 }
 294
 295
 296 void operator<<(LexicalConverter &conv, Timetable::RowType rt)
 297 {
 298         switch(rt)
 299         {
 300         case Timetable::ARRIVE: conv.result("ARRIVE"); return;
 301         case Timetable::DEPART: conv.result("DEPART"); return;
 302         case Timetable::THROUGH: conv.result("THROUGH"); return;
 303         default: throw lexical_error(format("conversion of RowType(%d) to string", rt));
 304         }
 305 }
 306
 307 void operator>>(const LexicalConverter &conv, Timetable::RowType &rt)
 308 {
 309         if(conv.get()=="ARRIVE")
 310                 rt = Timetable::ARRIVE;
 311         else if(conv.get()=="DEPART")
 312                 rt = Timetable::DEPART;
 313         else if(conv.get()=="THROUGH")
 314                 rt = Timetable::THROUGH;
 315         else
 316                 throw lexical_error(format("conversion of '%s' to RowType", conv.get()));
 317 }
 318
 319 } // namespace R2C2