Simplify some interfaces by using track and block iterators

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

diff --git a/source/libr2c2/route.cpp b/source/libr2c2/route.cpp
index be2eefc258ea8cfc7e135932e9ab325c1611ee96..80c61088eda68223be46299bac6621b289291d35 100644 (file)
--- a/source/libr2c2/route.cpp
+++ b/source/libr2c2/route.cpp
@@ -83,9 +83,9 @@ list<Track *> dijkstra(const TrackIter &from, const Pred &goal)
                        break;
                }
 
-               unsigned paths = lowest.track.endpoint().paths;
-               for(unsigned i=0; paths>>i; ++i)
-                       if(paths&(1<<i))
+               const TrackType::Endpoint &ep = lowest.track.endpoint();
+               for(unsigned i=0; ep.paths>>i; ++i)
+                       if(ep.has_path(i))
                        {
                                TrackIter next = lowest.track.next(i);
                                if(!next)
@@ -134,9 +134,9 @@ string bad_route::get_message(RouteValidityMask valid)
        unsigned i = 0;
        if(!(valid&1))
                reasons[i++] = "unlinked";
-       else if(!(valid&2))
+       if(!(valid&2))
                reasons[i++] = "branching";
-       else if(!(valid&4))
+       if(!(valid&4))
                reasons[i++] = "not smooth";
        return join(reasons, reasons+i, ", ");
 }
@@ -196,9 +196,9 @@ void Route::update_turnouts()
 
                                if(unsigned tid2 = links[j]->get_turnout_id())
                                {
-                                       const TrackType::Endpoint &ep = links[j]->get_type().get_endpoint(links[j]->get_endpoint_by_link(**i));
+                                       const TrackType::Endpoint &ep = links[j]->get_type().get_endpoint(links[j]->get_link_slot(**i));
                                        int p = get_turnout(tid2);
-                                       if(p>=0 && !(ep.paths&(1<<p)))
+                                       if(p>=0 && !ep.has_path(p))
                                        {
                                                // The linked track is a turnout and has a path which is incompatible with this endpoint
                                                mask &= ~endpoints[j].paths;
@@ -272,14 +272,21 @@ void Route::add_tracks(const set<Track *> &trks)
                if(!tracks.count(*i))
                        pending.insert(*i);
 
+       if(tracks.empty())
+       {
+               set<Track *>::iterator i = pending.begin();
+               tracks.insert(*i);
+               pending.erase(i);
+       }
+
        while(!pending.empty())
        {
                RouteValidityMask valid = ROUTE_INVALID;
-               for(set<Track *>::const_iterator i=pending.begin(); i!=pending.end(); ++i)
-                       if(tracks.empty() || (valid=check_validity(**i))==ROUTE_VALID)
+               for(set<Track *>::iterator i=pending.begin(); i!=pending.end(); ++i)
+                       if((valid=check_validity(**i))==ROUTE_VALID)
                        {
                                tracks.insert(*i);
-                               pending.erase(*i);
+                               pending.erase(i);
                                break;
                        }
 
@@ -290,9 +297,12 @@ void Route::add_tracks(const set<Track *> &trks)
        update_turnouts();
 }
 
-void Route::add_track_chain(Track &start, unsigned ep, const TurnoutMap &trnts)
+void Route::add_track_chain(const TrackIter &start, const TurnoutMap &trnts)
 {
-       TrackIter iter(&start, ep);
+       if(!start)
+               throw invalid_argument("Route::add_track_chain");
+
+       TrackIter iter = start;
        while(iter)
        {
                if(iter->get_type().is_dead_end())
@@ -345,12 +355,12 @@ RouteValidityMask Route::check_validity(Track &trk) const
 
                if(unsigned tid = (*i)->get_turnout_id())
                {
-                       const TrackType::Endpoint &ep = (*i)->get_type().get_endpoint((*i)->get_endpoint_by_link(trk));
+                       const TrackType::Endpoint &ep = (*i)->get_type().get_endpoint((*i)->get_link_slot(trk));
                        int path = get_turnout(tid);
                        if(path>=0)
                        {
                                // Linking to a turnout with path set is only good if we're continuing that path
-                               if(ep.paths&(1<<path))
+                               if(ep.has_path(path))
                                        result |= ROUTE_LINEAR;
                        }
                        else
@@ -364,17 +374,17 @@ RouteValidityMask Route::check_validity(Track &trk) const
                                                unsigned tid2 = tlinks[j]->get_turnout_id();
                                                if(tid2)
                                                {
-                                                       const TrackType::Endpoint &ep2 = tlinks[j]->get_type().get_endpoint(tlinks[j]->get_endpoint_by_link(**i));
+                                                       const TrackType::Endpoint &ep2 = tlinks[j]->get_type().get_endpoint(tlinks[j]->get_link_slot(**i));
                                                        path = get_turnout(tid2);
                                                        // Ignore a linked turnout with some other path set
-                                                       if(path>=0 && !(ep2.paths&(1<<path)))
+                                                       if(path>=0 && !ep2.has_path(path))
                                                                continue;
                                                }
 
                                                ++count;
 
                                                const TrackType::Endpoint &ep2 = (*i)->get_type().get_endpoint(j);
-                                               if(!(ep.paths&ep2.paths))
+                                               if(!ep.has_common_paths(ep2))
                                                        // Impossible path through the turnout - not good
                                                        result &= ~ROUTE_SMOOTH;
                                        }
@@ -438,16 +448,15 @@ void Route::Loader::finish()
                if(j==turnouts.end())
                        continue;
 
-               unsigned path_mask = 1<<j->second;
                const vector<TrackType::Endpoint> &eps = (*i)->get_type().get_endpoints();
                for(unsigned k=0; k<eps.size(); ++k)
-                       if(eps[k].paths&path_mask)
+                       if(eps[k].has_path(j->second))
                        {
                                Track *link = (*i)->get_link(k);
                                if(!obj.tracks.count(link))
-                                       obj.add_track_chain(*link, link->get_endpoint_by_link(**i), turnouts);
+                                       obj.add_track_chain(TrackIter(link, link->get_link_slot(**i)), turnouts);
                                if(!obj.tracks.count(*i))
-                                       obj.add_track_chain(**i, k, turnouts);
+                                       obj.add_track_chain(TrackIter(*i, k), turnouts);
                                break;
                        }