Convert designer to use mspgltk for UI

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

diff --git a/source/libmarklin/route.cpp b/source/libmarklin/route.cpp
index 7199fc9b940f73d9dcba18b9d08bc45228038bef..fa2286cc65aef625848101bc7b7c77c9d020d055 100644 (file)
--- a/source/libmarklin/route.cpp
+++ b/source/libmarklin/route.cpp
@@ -1,14 +1,186 @@
 /* $Id$
 
 This file is part of the MSP Märklin suite
-Copyright © 2006-2008 Mikkosoft Productions, Mikko Rasa
+Copyright © 2007-2009  Mikkosoft Productions, Mikko Rasa
 Distributed under the GPL
 */
 
+#include "track.h"
+#include "tracktype.h"
 #include "route.h"
 
+using namespace std;
+using namespace Msp;
+
 namespace Marklin {
 
+Route::Route(const string &n):
+       name(n)
+{ }
+
+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 r = get_turnout(tid2);
+                                       if(r>=0 && !(ep.routes&(1<<r)))
+                                       {
+                                               mask &= ~endpoints[j].routes;
+                                               continue;
+                                       }
+                               }
+                               mask &= endpoints[j].routes;
+                       }
+
+                       if(!(mask&(mask-1)))
+                       {
+                               unsigned route = 0;
+                               for(; (mask && !(mask&1)); mask>>=1, ++route) ;
+                               turnouts[tid] = route;
+                       }
+                       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].routes&(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].routes&endpoints[epj].routes))
+                                                       result &= 3;
+                                       }
+                               }
+                       }
+                       else
+                               result |= 2;
+               }
+       }
+
+       return result;
+}
+
+
+Route::Loader::Loader(Route &r):
+       DataFile::BasicLoader<Route>(r)
+{
+       add("turnout", &Loader::turnout);
+}
 
+void Route::Loader::turnout(unsigned id, unsigned route)
+{
+       obj.turnouts[id] = route;
+}
 
 } // namespace Marklin