Change terminology to better distinguish routes on the layout from paths across track...

[r2c2.git] / source / libmarklin / route.cpp

diff --git a/source/libmarklin/route.cpp b/source/libmarklin/route.cpp
index 98943985db147044acc4fa9b4aee06e9f2fde8d3..40638d9683051fd3fa4581b14f3d6458d89d4880 100644 (file)
--- a/source/libmarklin/route.cpp
+++ b/source/libmarklin/route.cpp
@@ -1,7 +1,194 @@
+/* $Id$
+
+This file is part of the MSP Märklin suite
+Copyright © 2007-2009  Mikkosoft Productions, Mikko Rasa
+Distributed under the GPL
+*/
+
+#include "layout.h"
 #include "route.h"
+#include "track.h"
+#include "tracktype.h"
+
+using namespace std;
+using namespace Msp;
 
 namespace Marklin {
 
+Route::Route(Layout &layout, const string &n):
+       name(n)
+{
+       layout.signal_track_removed.connect(sigc::mem_fun(this, &Route::track_removed));
+}
+
+int Route::get_turnout(unsigned id) const
+{
+       map<unsigned, int>::const_iterator i = turnouts.find(id);
+       if(i!=turnouts.end())
+               return i->second;
+       return -1;
+}
+
+void Route::add_track(const Track &trk)
+{
+       if(tracks.count(&trk))
+               return;
+
+       if(!tracks.empty())
+       {
+               unsigned valid = check_validity(trk);
+               if(!(valid&1))
+                       throw Exception("Not linked to existing tracks");
+               else if(!(valid&2))
+                       throw Exception("Branching routes not allowed");
+               else if(!(valid&4))
+                       throw Exception("Route must be smooth");
+       }
+
+       tracks.insert(&trk);
+       update_turnouts();
+}
+
+void Route::add_tracks(const set<const Track *> &trks)
+{
+       set<const Track *> pending;
+       for(set<const Track *>::const_iterator i=trks.begin(); i!=trks.end(); ++i)
+               if(!tracks.count(*i))
+                       pending.insert(*i);
+
+       while(!pending.empty())
+       {
+               bool found = false;
+               for(set<const Track *>::const_iterator i=pending.begin(); i!=pending.end(); ++i)
+                       if(tracks.empty() || check_validity(**i)==7)
+                       {
+                               tracks.insert(*i);
+                               pending.erase(*i);
+                               found = true;
+                               break;
+                       }
+
+               if(!found)
+                       throw Exception("Could not add all tracks to route");
+       }
+
+       update_turnouts();
+}
+
+void Route::save(list<DataFile::Statement> &st) const
+{
+       for(map<unsigned, int>::const_iterator i=turnouts.begin(); i!=turnouts.end(); ++i)
+               st.push_back((DataFile::Statement("turnout"), i->first, i->second));
+}
+
+void Route::update_turnouts()
+{
+       set<unsigned> found;
+       for(set<const Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               if(unsigned tid=(*i)->get_turnout_id())
+               {
+                       found.insert(tid);
+
+                       const vector<Endpoint> &endpoints = (*i)->get_type().get_endpoints();
+                       const vector<Track *> &links = (*i)->get_links();
+
+                       unsigned mask = 15;
+                       for(unsigned j=0; j<endpoints.size(); ++j)
+                       {
+                               if(!tracks.count(links[j]))
+                                       continue;
+                               if(unsigned tid2=links[j]->get_turnout_id())
+                               {
+                                       const Endpoint &ep = links[j]->get_type().get_endpoints()[links[j]->get_endpoint_by_link(**i)];
+                                       int p = get_turnout(tid2);
+                                       if(p>=0 && !(ep.paths&(1<<p)))
+                                       {
+                                               mask &= ~endpoints[j].paths;
+                                               continue;
+                                       }
+                               }
+                               mask &= endpoints[j].paths;
+                       }
+
+                       if(!(mask&(mask-1)))
+                       {
+                               unsigned path = 0;
+                               for(; (mask && !(mask&1)); mask>>=1, ++path) ;
+                               turnouts[tid] = path;
+                       }
+                       else
+                               turnouts[tid] = -1;
+               }
+
+       for(map<unsigned, int>::iterator i=turnouts.begin(); i!=turnouts.end();)
+       {
+               if(!found.count(i->first))
+                       turnouts.erase(i++);
+               else
+                       ++i;
+       }
+}
+
+unsigned Route::check_validity(const Track &trk) const
+{
+       unsigned result = 4;
+       for(set<const Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       {
+               int epi=(*i)->get_endpoint_by_link(trk);
+               if(epi>=0)
+               {
+                       result |= 1;
+                       const vector<Endpoint> &endpoints = (*i)->get_type().get_endpoints();
+                       if(unsigned tid=(*i)->get_turnout_id())
+                       {
+                               int r = get_turnout(tid);
+                               if(r>=0)
+                               {
+                                       if(endpoints[epi].paths&(1<<r))
+                                               result |= 2;
+                               }
+                               else
+                               {
+                                       unsigned count = 0;
+                                       const vector<Track *> &links = (*i)->get_links();
+                                       int epj = -1;
+                                       for(unsigned k=0; k<endpoints.size(); ++k)
+                                               if(tracks.count(links[k]))
+                                               {
+                                                       ++count;
+                                                       epj = k;
+                                               }
+                                       if(count<=1)
+                                       {
+                                               result |= 2;
+                                               if(epj>=0 && !(endpoints[epi].paths&endpoints[epj].paths))
+                                                       result &= 3;
+                                       }
+                               }
+                       }
+                       else
+                               result |= 2;
+               }
+       }
+
+       return result;
+}
+
+void Route::track_removed(Track &t)
+{
+       tracks.erase(&t);
+}
+
+
+Route::Loader::Loader(Route &r):
+       DataFile::BasicLoader<Route>(r)
+{
+       add("turnout", &Loader::turnout);
+}
 
+void Route::Loader::turnout(unsigned id, unsigned path)
+{
+       obj.turnouts[id] = path;
+}
 
 } // namespace Marklin