Ticket #730: route.c.diff

File route.c.diff, 9.9 KB (added by bjoernchr74, 10 years ago)
Line 
1*** ../../sdk/navit/navit/route.c       2011-01-15 15:27:29.922573836 +0100
2--- route.c     2011-01-15 13:41:50.252573498 +0100
3***************
4*** 129,134 ****
5--- 129,136 ----
6 
7  #define RSD_OFFSET(x) *((int *)route_segment_data_field_pos((x), attr_offset))
8  #define RSD_MAXSPEED(x) *((int *)route_segment_data_field_pos((x), attr_maxspeed))
9+ #define RSD_MAXSPEED_FORWARD(x) *((int *)route_segment_data_field_pos((x), attr_maxspeed_forward))
10+ #define RSD_MAXSPEED_BACKWARD(x) *((int *)route_segment_data_field_pos((x), attr_maxspeed_backward))
11  #define RSD_SIZE_WEIGHT(x) *((struct size_weight_limit *)route_segment_data_field_pos((x), attr_vehicle_width))
12  #define RSD_DANGEROUS_GOODS(x) *((int *)route_segment_data_field_pos((x), attr_vehicle_dangerous_goods))
13 
14***************
15*** 139,144 ****
16--- 141,148 ----
17        int flags;
18        int len;
19        int maxspeed;
20+       int maxspeed_forward;
21+       int maxspeed_backward;
22        struct size_weight_limit size_weight;
23        int dangerous_goods;
24  };
25***************
26*** 1235,1247 ****
27        ptr = ((unsigned char*)seg) + sizeof(struct route_segment_data);
28 
29        if (seg->flags & AF_SPEED_LIMIT) {
30!               if (type == attr_maxspeed)
31                        return (void*)ptr;
32                ptr += sizeof(int);
33        }
34        if (seg->flags & AF_SEGMENTED) {
35!               if (type == attr_offset)
36                        return (void*)ptr;
37                ptr += sizeof(int);
38        }
39        if (seg->flags & AF_SIZE_OR_WEIGHT_LIMIT) {
40--- 1239,1261 ----
41        ptr = ((unsigned char*)seg) + sizeof(struct route_segment_data);
42 
43        if (seg->flags & AF_SPEED_LIMIT) {
44!               if (type == attr_maxspeed)
45                        return (void*)ptr;
46+
47+               ptr += sizeof(int);
48+               if (type == attr_maxspeed_forward)
49+                       return (void*)ptr;
50+
51+               ptr += sizeof(int);
52+               if (type == attr_maxspeed_backward)
53+                       return (void*)ptr;
54+
55                ptr += sizeof(int);
56        }
57        if (seg->flags & AF_SEGMENTED) {
58!               if (type == attr_offset)
59                        return (void*)ptr;
60+
61                ptr += sizeof(int);
62        }
63        if (seg->flags & AF_SIZE_OR_WEIGHT_LIMIT) {
64***************
65*** 1268,1274 ****
66  {
67        int ret=sizeof(struct route_segment_data);
68        if (flags & AF_SPEED_LIMIT)
69!               ret+=sizeof(int);
70        if (flags & AF_SEGMENTED)
71                ret+=sizeof(int);
72        if (flags & AF_SIZE_OR_WEIGHT_LIMIT)
73--- 1282,1288 ----
74  {
75        int ret=sizeof(struct route_segment_data);
76        if (flags & AF_SPEED_LIMIT)
77!               ret+=sizeof(int)*3; // maxspeed, maxspeed_foward, maxspeed_backward
78        if (flags & AF_SEGMENTED)
79                ret+=sizeof(int);
80        if (flags & AF_SIZE_OR_WEIGHT_LIMIT)
81***************
82*** 1311,1317 ****
83   * @param item The item that is represented by this segment
84   * @param flags Flags for this segment
85   * @param offset If the item passed in "item" is segmented (i.e. divided into several segments), this indicates the position of this segment within the item
86!  * @param maxspeed The maximum speed allowed on this segment in km/h. -1 if not known.
87   */
88  static void
89  route_graph_add_segment(struct route_graph *this, struct route_graph_point *start,
90--- 1325,1333 ----
91   * @param item The item that is represented by this segment
92   * @param flags Flags for this segment
93   * @param offset If the item passed in "item" is segmented (i.e. divided into several segments), this indicates the position of this segment within the item
94!  * @param maxspeed          The maximum speed allowed on this segment in km/h. -1 if not known.
95!  * @param maxspeed_forward  The maximum speed allowed on this segment in km/h. -1 if not known.
96!  * @param maxspeed_backward The maximum speed allowed on this segment in km/h. -1 if not known.
97   */
98  static void
99  route_graph_add_segment(struct route_graph *this, struct route_graph_point *start,
100***************
101*** 1337,1344 ****
102        s->data.item=*data->item;
103        s->data.flags=data->flags;
104 
105!       if (data->flags & AF_SPEED_LIMIT)
106                RSD_MAXSPEED(&s->data)=data->maxspeed;
107        if (data->flags & AF_SEGMENTED)
108                RSD_OFFSET(&s->data)=data->offset;
109        if (data->flags & AF_SIZE_OR_WEIGHT_LIMIT)
110--- 1353,1363 ----
111        s->data.item=*data->item;
112        s->data.flags=data->flags;
113 
114!       if (data->flags & AF_SPEED_LIMIT) {
115                RSD_MAXSPEED(&s->data)=data->maxspeed;
116+               RSD_MAXSPEED_FORWARD(&s->data)=data->maxspeed_forward;
117+               RSD_MAXSPEED_BACKWARD(&s->data)=data->maxspeed_backward;
118+     }
119        if (data->flags & AF_SEGMENTED)
120                RSD_OFFSET(&s->data)=data->offset;
121        if (data->flags & AF_SIZE_OR_WEIGHT_LIMIT)
122***************
123*** 1796,1801 ****
124--- 1815,1822 ----
125        data.flags=0;
126        data.offset=1;
127        data.maxspeed = INT_MAX;
128+       data.maxspeed_forward = INT_MAX;
129+       data.maxspeed_backward = INT_MAX;
130 
131        if (item_coord_get(item, &l, 1)) {
132                s_pnt=route_graph_add_point(this,&l);
133***************
134*** 1809,1814 ****
135--- 1830,1843 ----
136                        data.flags |= AF_SPEED_LIMIT;
137                        data.maxspeed=maxspeed_attr.u.num;
138                }
139+               if (item_attr_get(item, attr_maxspeed_forward, &maxspeed_attr)) {
140+                       data.flags |= AF_SPEED_LIMIT;
141+                       data.maxspeed_forward=maxspeed_attr.u.num;
142+               }
143+               if (item_attr_get(item, attr_maxspeed_backward, &maxspeed_attr)) {
144+                       data.flags |= AF_SPEED_LIMIT;
145+                       data.maxspeed_backward=maxspeed_attr.u.num;
146+               }
147                if (item_attr_get(item, attr_delay, &delay_attr))
148                        data.len=delay_attr.u.num;
149                route_graph_add_segment(this, s_pnt, e_pnt, &data);
150***************
151*** 1879,1884 ****
152--- 1908,1915 ----
153        data.flags=0;
154        data.offset=1;
155        data.maxspeed=-1;
156+       data.maxspeed_forward=-1;
157+       data.maxspeed_backward=-1;
158        data.item=item;
159        int segmented = 0;
160        struct roadprofile *roadp;
161***************
162*** 1904,1909 ****
163--- 1935,1944 ----
164                if (data.flags & AF_SPEED_LIMIT) {
165                        if (item_attr_get(item, attr_maxspeed, &attr))
166                                data.maxspeed = attr.u.num;
167+                       if (item_attr_get(item, attr_maxspeed_forward, &attr))
168+                               data.maxspeed_forward = attr.u.num;
169+                       if (item_attr_get(item, attr_maxspeed_backward, &attr))
170+                               data.maxspeed_backward = attr.u.num;
171                }
172                if (data.flags & AF_DANGEROUS_GOODS) {
173                        if (item_attr_get(item, attr_vehicle_dangerous_goods, &attr))
174***************
175*** 2357,2366 ****
176        data.flags=s->data.flags|flags;
177        data.offset=1;
178        data.maxspeed=-1;
179        data.item=&s->data.item;
180        data.len=s->data.len+1;
181!       if (s->data.flags & AF_SPEED_LIMIT)
182                data.maxspeed=RSD_MAXSPEED(&s->data);
183        if (s->data.flags & AF_SEGMENTED)
184                data.offset=RSD_OFFSET(&s->data);
185        dbg(1,"cloning segment from %p (0x%x,0x%x) to %p (0x%x,0x%x)\n",start,start->c.x,start->c.y, end, end->c.x, end->c.y);
186--- 2392,2406 ----
187        data.flags=s->data.flags|flags;
188        data.offset=1;
189        data.maxspeed=-1;
190+       data.maxspeed_forward=-1;
191+       data.maxspeed_backward=-1;
192        data.item=&s->data.item;
193        data.len=s->data.len+1;
194!       if (s->data.flags & AF_SPEED_LIMIT) {
195                data.maxspeed=RSD_MAXSPEED(&s->data);
196+               data.maxspeed_forward=RSD_MAXSPEED_FORWARD(&s->data);
197+               data.maxspeed_backward=RSD_MAXSPEED_BACKWARD(&s->data);
198+     }
199        if (s->data.flags & AF_SEGMENTED)
200                data.offset=RSD_OFFSET(&s->data);
201        dbg(1,"cloning segment from %p (0x%x,0x%x) to %p (0x%x,0x%x)\n",start,start->c.x,start->c.y, end, end->c.x, end->c.y);
202***************
203*** 2627,2638 ****
204        }
205 
206        ret->maxspeed = -1;
207        if (ret->flags & AF_SPEED_LIMIT) {
208!               if (item_attr_get(item, attr_maxspeed, &maxspeed_attr)) {
209!                       ret->maxspeed = maxspeed_attr.u.num;
210!               }
211!       }
212 
213        return ret;
214  }
215 
216--- 2667,2685 ----
217        }
218 
219        ret->maxspeed = -1;
220+     ret->maxspeed_forward = -1;
221+     ret->maxspeed_backward = -1;
222+
223        if (ret->flags & AF_SPEED_LIMIT) {
224!               if (item_attr_get(item, attr_maxspeed, &maxspeed_attr))
225!             ret->maxspeed = maxspeed_attr.u.num;
226!
227!               if (item_attr_get(item, attr_maxspeed_forward, &maxspeed_attr))
228!             ret->maxspeed_forward = maxspeed_attr.u.num;
229 
230+               if (item_attr_get(item, attr_maxspeed_backward, &maxspeed_attr))
231+             ret->maxspeed_backward = maxspeed_attr.u.num;
232+       }
233        return ret;
234  }
235 
236***************
237*** 2854,2860 ****
238                        }
239                        return 0;
240                case attr_maxspeed:
241!                       mr->attr_next = attr_street_item;
242                        if (seg && seg->data->flags && AF_SPEED_LIMIT) {
243                                attr->u.num=RSD_MAXSPEED(seg->data);
244 
245--- 2901,2907 ----
246                        }
247                        return 0;
248                case attr_maxspeed:
249!                       mr->attr_next = attr_maxspeed_forward;
250                        if (seg && seg->data->flags && AF_SPEED_LIMIT) {
251                                attr->u.num=RSD_MAXSPEED(seg->data);
252 
253***************
254*** 2862,2867 ****
255--- 2909,2932 ----
256                                return 0;
257                        }
258                        return 1;
259+               case attr_maxspeed_forward:
260+                       mr->attr_next = attr_maxspeed_backward;
261+                       if (seg && seg->data->flags && AF_SPEED_LIMIT) {
262+                               attr->u.num=RSD_MAXSPEED_FORWARD(seg->data);
263+
264+                       } else {
265+                               return 0;
266+                       }
267+                       return 1;
268+               case attr_maxspeed_backward:
269+                       mr->attr_next = attr_street_item;
270+                       if (seg && seg->data->flags && AF_SPEED_LIMIT) {
271+                               attr->u.num=RSD_MAXSPEED_BACKWARD(seg->data);
272+
273+                       } else {
274+                               return 0;
275+                       }
276+                       return 1;
277                case attr_street_item:
278                        mr->attr_next=attr_direction;
279                        if (seg && seg->data->item.map)
280***************
281*** 2977,2983 ****
282                }
283                return 0;
284        case attr_maxspeed:
285!               mr->attr_next = attr_label;
286                if (mr->item.type != type_rg_segment)
287                        return 0;
288                if (seg && (seg->data.flags & AF_SPEED_LIMIT)) {
289--- 3042,3048 ----
290                }
291                return 0;
292        case attr_maxspeed:
293!               mr->attr_next = attr_maxspeed_forward;
294                if (mr->item.type != type_rg_segment)
295                        return 0;
296                if (seg && (seg->data.flags & AF_SPEED_LIMIT)) {
297***************
298*** 2987,2992 ****
299--- 3052,3079 ----
300                } else {
301                        return 0;
302                }
303+       case attr_maxspeed_forward:
304+               mr->attr_next = attr_maxspeed_backward;
305+               if (mr->item.type != type_rg_segment)
306+                       return 0;
307+               if (seg && (seg->data.flags & AF_SPEED_LIMIT)) {
308+                       attr->type = attr_maxspeed_forward;
309+                       attr->u.num=RSD_MAXSPEED_FORWARD(&seg->data);
310+                       return 1;
311+               } else {
312+                       return 0;
313+               }
314+       case attr_maxspeed_backward:
315+               mr->attr_next = attr_label;
316+               if (mr->item.type != type_rg_segment)
317+                       return 0;
318+               if (seg && (seg->data.flags & AF_SPEED_LIMIT)) {
319+                       attr->type = attr_maxspeed_backward;
320+                       attr->u.num=RSD_MAXSPEED_BACKWARD(&seg->data);
321+                       return 1;
322+               } else {
323+                       return 0;
324+               }
325        case attr_label:
326                mr->attr_next=attr_street_item;
327                if (mr->item.type != type_rg_point)