Code reformatting: add spaces around assignment operators

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

diff --git a/source/libmarklin/track.cpp b/source/libmarklin/track.cpp
index 73674ee8c39f340cf7665e153ff3908544a33b29..01b789373c6fb655b712a6558533ec588adc08f9 100644 (file)
--- a/source/libmarklin/track.cpp
+++ b/source/libmarklin/track.cpp
@@ -31,28 +31,28 @@ Track::~Track()
 
 void Track::set_position(const Point &p)
 {
-       pos=p;
+       pos = p;
 }
 
 void Track::set_rotation(float r)
 {
-       rot=r;
+       rot = r;
        while(rot<0)
-               rot+=M_PI*2;
+               rot += M_PI*2;
        while(rot>M_PI*2)
-               rot-=M_PI*2;
+               rot -= M_PI*2;
 }
 
 void Track::set_slope(float s)
 {
        if(links.size()!=2) return;
 
-       slope=s;
+       slope = s;
 }
 
 void Track::set_flex(bool f)
 {
-       flex=f;
+       flex = f;
 }
 
 void Track::check_slope()
@@ -62,35 +62,35 @@ void Track::check_slope()
 
        if(links[0] && links[1])
        {
-               Point epp0=links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
-               Point epp1=links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
-               pos.z=epp0.z;
-               slope=epp1.z-pos.z;
+               Point epp0 = links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
+               Point epp1 = links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
+               pos.z = epp0.z;
+               slope = epp1.z-pos.z;
        }
        else
        {
-               slope=0;
+               slope = 0;
                if(links[0])
                {
-                       Point epp=links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
-                       pos.z=epp.z;
+                       Point epp = links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
+                       pos.z = epp.z;
                }
                else if(links[1])
                {
-                       Point epp=links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
-                       pos.z=epp.z;
+                       Point epp = links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
+                       pos.z = epp.z;
                }
        }
 }
 
 void Track::set_turnout_id(unsigned i)
 {
-       turnout_id=i;
+       turnout_id = i;
 }
 
 void Track::set_sensor_id(unsigned i)
 {
-       sensor_id=i;
+       sensor_id = i;
 }
 
 int Track::get_endpoint_by_link(const Track &other) const
@@ -104,50 +104,50 @@ int Track::get_endpoint_by_link(const Track &other) const
 
 Point Track::get_endpoint_position(unsigned epi) const
 {
-       const vector<Endpoint> &eps=type.get_endpoints();
+       const vector<Endpoint> &eps = type.get_endpoints();
        if(epi>=eps.size())
                throw InvalidParameterValue("Endpoint index out of range");
 
-       const Endpoint &ep=eps[epi];
+       const Endpoint &ep = eps[epi];
 
-       float c=cos(rot);
-       float s=sin(rot);
+       float c = cos(rot);
+       float s = sin(rot);
 
        Point p(pos.x+c*ep.pos.x-s*ep.pos.y, pos.y+s*ep.pos.x+c*ep.pos.y, pos.z);
        if(eps.size()==2 && epi==1)
-               p.z+=slope;
+               p.z += slope;
        return p;
 }
 
 float Track::get_endpoint_direction(unsigned epi) const
 {
-       const vector<Endpoint> &eps=type.get_endpoints();
+       const vector<Endpoint> &eps = type.get_endpoints();
        if(epi>=eps.size())
                throw InvalidParameterValue("Endpoint index out of range");
 
-       const Endpoint &ep=eps[epi];
+       const Endpoint &ep = eps[epi];
 
        return rot+ep.dir;
 }
 
 bool Track::snap_to(Track &other, bool link)
 {
-       float limit=(link && !flex) ? 1e-6 : 1e-4;
-       const vector<Endpoint> &eps=type.get_endpoints();
-       const vector<Endpoint> &other_eps=other.get_type().get_endpoints();
+       float limit = (link && !flex) ? 1e-6 : 1e-4;
+       const vector<Endpoint> &eps = type.get_endpoints();
+       const vector<Endpoint> &other_eps = other.get_type().get_endpoints();
 
        for(unsigned i=0; i<eps.size(); ++i)
        {
-               Point epp=get_endpoint_position(i);
+               Point epp = get_endpoint_position(i);
 
                for(unsigned j=0; j<other_eps.size(); ++j)
                {
                        if(other.get_link(j))
                                continue;
 
-                       Point epp2=other.get_endpoint_position(j);
-                       float dx=epp2.x-epp.x;
-                       float dy=epp2.y-epp.y;
+                       Point epp2 = other.get_endpoint_position(j);
+                       float dx = epp2.x-epp.x;
+                       float dy = epp2.y-epp.y;
                        if(dx*dx+dy*dy<limit)
                        {
                                set_rotation(other.rot+other_eps[j].dir-eps[i].dir+M_PI);
@@ -157,8 +157,8 @@ bool Track::snap_to(Track &other, bool link)
                                {
                                        if(links[i])
                                                break_link(*links[i]);
-                                       links[i]=&other;
-                                       other.links[j]=this;
+                                       links[i] = &other;
+                                       other.links[j] = this;
                                }
 
                                return true;
@@ -171,17 +171,17 @@ bool Track::snap_to(Track &other, bool link)
 
 bool Track::snap(Point &pt, float &d) const
 {
-       const vector<Endpoint> &eps=type.get_endpoints();
+       const vector<Endpoint> &eps = type.get_endpoints();
 
        for(unsigned i=0; i<eps.size(); ++i)
        {
-               Point epp=get_endpoint_position(i);
-               float dx=pt.x-epp.x;
-               float dy=pt.y-epp.y;
+               Point epp = get_endpoint_position(i);
+               float dx = pt.x-epp.x;
+               float dy = pt.y-epp.y;
                if(dx*dx+dy*dy<1e-4)
                {
-                       pt=epp;
-                       d=rot+eps[i].dir;
+                       pt = epp;
+                       d = rot+eps[i].dir;
                        return true;
                }
        }
@@ -194,7 +194,7 @@ void Track::break_link(Track &trk)
        for(vector<Track *>::iterator i=links.begin(); i!=links.end(); ++i)
                if(*i==&trk)
                {
-                       *i=0;
+                       *i = 0;
                        trk.break_link(*this);
                        return;
                }
@@ -205,7 +205,7 @@ void Track::break_links()
        for(vector<Track *>::iterator i=links.begin(); i!=links.end(); ++i)
                if(Track *trk=*i)
                {
-                       *i=0;
+                       *i = 0;
                        trk->break_link(*this);
                }
 }
@@ -220,11 +220,11 @@ Track *Track::get_link(unsigned i) const
 
 int Track::traverse(unsigned i, unsigned route) const
 {
-       const vector<Endpoint> &eps=type.get_endpoints();
+       const vector<Endpoint> &eps = type.get_endpoints();
        if(i>=eps.size())
                throw InvalidParameterValue("Endpoint index out of range");
 
-       const Endpoint &ep=eps[i];
+       const Endpoint &ep = eps[i];
        
        if(ep.routes&(1<<route))
        {
@@ -246,15 +246,15 @@ int Track::traverse(unsigned i, unsigned route) const
 
 Point Track::get_point(unsigned epi, unsigned route, float d) const
 {
-       const vector<Endpoint> &eps=type.get_endpoints();
+       const vector<Endpoint> &eps = type.get_endpoints();
        if(epi>=eps.size())
                throw InvalidParameterValue("Endpoint index out of range");
 
-       float x=eps[epi].pos.x;
-       float y=eps[epi].pos.y;
+       float x = eps[epi].pos.x;
+       float y = eps[epi].pos.y;
 
-       const vector<TrackPart> &parts=type.get_parts();
-       const TrackPart *last_part=0;
+       const vector<TrackPart> &parts = type.get_parts();
+       const TrackPart *last_part = 0;
        while(1)
        {
                for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
@@ -268,29 +268,29 @@ Point Track::get_point(unsigned epi, unsigned route, float d) const
                        i->collect_endpoints(part_eps);
                        for(unsigned j=0; j<part_eps.size(); ++j)
                        {
-                               float dx=part_eps[j].pos.x-x;
-                               float dy=part_eps[j].pos.y-y;
+                               float dx = part_eps[j].pos.x-x;
+                               float dy = part_eps[j].pos.y-y;
                                if(dx*dx+dy*dy<1e-6)
                                {
-                                       float plen=i->length;
+                                       float plen = i->length;
                                        if(i->radius)
-                                               plen*=abs(i->radius);
+                                               plen *= abs(i->radius);
                                        if(d<plen)
                                        {
                                                if(j==1)
-                                                       d=plen-d;
-                                               Point p=i->get_point(d);
-                                               float c=cos(rot);
-                                               float s=sin(rot);
+                                                       d = plen-d;
+                                               Point p = i->get_point(d);
+                                               float c = cos(rot);
+                                               float s = sin(rot);
                                                return Point(pos.x+c*p.x-s*p.y, pos.y+c*p.y+s*p.x);
                                        }
                                        else if(part_eps.size()>1)
                                        {
-                                               d-=plen;
-                                               x=part_eps[1-j].pos.x;
-                                               y=part_eps[1-j].pos.y;
-                                               last_part=&*i;
-                                               i=parts.begin();
+                                               d -= plen;
+                                               x = part_eps[1-j].pos.x;
+                                               y = part_eps[1-j].pos.y;
+                                               last_part = &*i;
+                                               i = parts.begin();
                                                break;
                                        }
                                        else
@@ -308,7 +308,7 @@ Point Track::get_point(unsigned epi, unsigned route, float d) const
 
 Track *Track::copy() const
 {
-       Track *trk=new Track(type);
+       Track *trk = new Track(type);
        trk->set_position(pos);
        trk->set_rotation(rot);
        trk->set_slope(slope);
@@ -344,7 +344,7 @@ Track::Loader::Loader(Track &t):
 
 void Track::Loader::position(float x, float y, float z)
 {
-       obj.pos=Point(x, y, z);
+       obj.pos = Point(x, y, z);
 }
 
 } // namespace Marklin