trunk/src/relationsx.c

/***************************************
 $Header: /home/amb/CVS/routino/src/relationsx.c,v 1.1 2010-09-17 17:42:45 amb Exp $

 Extended Relation data type functions.

 Part of the Routino routing software.
 ******************/ /******************
 This file Copyright 2010 Andrew M. Bishop

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Affero General Public License for more details.

 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ***************************************/


#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

#include "waysx.h"
#include "relationsx.h"

#include "files.h"
#include "functions.h"


/* Variables */

/*+ The command line '--tmpdir' option or its default value. +*/
extern char *option_tmpdirname;

/*+ A temporary file-local variable for use by the sort functions. +*/
static RelationsX *sortrelationsx;

/* Functions */

static int sort_by_id(RouteRelX *a,RouteRelX *b);
static int deduplicate_by_id(RouteRelX *relationx,index_t index);


/*++++++++++++++++++++++++++++++++++++++
  Allocate a new relation list (create a new file or open an existing one).

  RelationsX *NewRelationList Returns the relation list.

  int append Set to 1 if the file is to be opened for appending (now or later).
  ++++++++++++++++++++++++++++++++++++++*/

RelationsX *NewRelationList(int append)
{
 RelationsX *relationsx;

 relationsx=(RelationsX*)calloc(1,sizeof(RelationsX));

 assert(relationsx); /* Check calloc() worked */

 relationsx->rfilename=(char*)malloc(strlen(option_tmpdirname)+32);

 if(append)
    sprintf(relationsx->rfilename,"%s/relationsx.route.input.tmp",option_tmpdirname);
 else
    sprintf(relationsx->rfilename,"%s/relationsx.route.%p.tmp",option_tmpdirname,relationsx);

 if(append)
   {
    off_t size,position=0;

    relationsx->rfd=AppendFile(relationsx->rfilename);

    size=SizeFile(relationsx->rfilename);

    while(position<size)
      {
       FILESORT_VARINT relationsize;

       SeekFile(relationsx->rfd,position);
       ReadFile(relationsx->rfd,&relationsize,FILESORT_VARSIZE);

       relationsx->rxnumber++;
       position+=relationsize+FILESORT_VARSIZE;
      }

    SeekFile(relationsx->rfd,size);
   }
 else
    relationsx->rfd=OpenFile(relationsx->rfilename);

 return(relationsx);
}


/*++++++++++++++++++++++++++++++++++++++
  Free a relation list.

  RelationsX *relationsx The list to be freed.

  int keep Set to 1 if the file is to be kept.
  ++++++++++++++++++++++++++++++++++++++*/

void FreeRelationList(RelationsX *relationsx,int keep)
{
 if(!keep)
    DeleteFile(relationsx->rfilename);

 free(relationsx->rfilename);

 free(relationsx);
}


/*++++++++++++++++++++++++++++++++++++++
  Append a single relation to an unsorted route relation list.

  RelationsX* relationsx The set of relations to process.

  relation_t id The ID of the relation.

  allow_t routes The types of routes that this relation is for.

  way_t *ways The array of ways that are members of the relation.

  int nways The number of ways that are members of the relation.

  relation_t *relations The array of relations that are members of the relation.

  int nrelations The number of relations that are members of the relation.
  ++++++++++++++++++++++++++++++++++++++*/

void AppendRouteRelation(RelationsX* relationsx,relation_t id,allow_t routes,
                         way_t *ways,int nways,
                         relation_t *relations,int nrelations)
{
 RouteRelX relationx;
 FILESORT_VARINT size,padsize;
 way_t zeroway=0;
 relation_t zerorelation=0;
 void *zeropointer=NULL;

 relationx.id=id;
 relationx.routes=routes;

 size=sizeof(RouteRelX)+(nways+1)*sizeof(way_t)+(nrelations+1)*sizeof(relation_t);
 padsize=sizeof(RouteRelX*)*((size+sizeof(RouteRelX*)-1)/sizeof(RouteRelX*));

 WriteFile(relationsx->rfd,&padsize,FILESORT_VARSIZE);
 WriteFile(relationsx->rfd,&relationx,sizeof(RouteRelX));

 WriteFile(relationsx->rfd,ways    ,nways*sizeof(way_t));
 WriteFile(relationsx->rfd,&zeroway,      sizeof(way_t));

 WriteFile(relationsx->rfd,relations    ,nrelations*sizeof(relation_t));
 WriteFile(relationsx->rfd,&zerorelation,           sizeof(relation_t));

 WriteFile(relationsx->rfd,&zeropointer,padsize-size);

 relationsx->rxnumber++;

 assert(!(relationsx->rxnumber==0)); /* Zero marks the high-water mark for relations. */
}


/*++++++++++++++++++++++++++++++++++++++
  Sort the list of relations.

  RelationsX* relationsx The set of relations to process.
  ++++++++++++++++++++++++++++++++++++++*/

void SortRelationList(RelationsX* relationsx)
{
 int rfd;

 /* Print the start message */

 printf("Sorting Relations");
 fflush(stdout);

 /* Close the file and re-open it (finished appending) */

 CloseFile(relationsx->rfd);
 relationsx->rfd=ReOpenFile(relationsx->rfilename);

 DeleteFile(relationsx->rfilename);

 rfd=OpenFile(relationsx->rfilename);

 /* Sort the relations to allow removing duplicates */

 sortrelationsx=relationsx;

 filesort_vary(relationsx->rfd,rfd,(int (*)(const void*,const void*))sort_by_id,(int (*)(void*,index_t))deduplicate_by_id);

 /* Close the files */

 CloseFile(relationsx->rfd);
 CloseFile(rfd);

 /* Print the final message */

 printf("\rSorted Relations: Relations=%d Duplicates=%d\n",relationsx->rxnumber,relationsx->rxnumber-relationsx->rnumber);
 fflush(stdout);
}


/*++++++++++++++++++++++++++++++++++++++
  Sort the relations into id order.

  int sort_by_id Returns the comparison of the id fields.

  RouteRelX *a The first extended relation.

  RouteRelX *b The second extended relation.
  ++++++++++++++++++++++++++++++++++++++*/

static int sort_by_id(RouteRelX *a,RouteRelX *b)
{
 relation_t a_id=a->id;
 relation_t b_id=b->id;

 if(a_id<b_id)
    return(-1);
 else if(a_id>b_id)
    return(1);
 else
    return(0);
}


/*++++++++++++++++++++++++++++++++++++++
  Deduplicate the extended relations using the id after sorting.

  int deduplicate_by_id Return 1 if the value is to be kept, otherwise zero.

  RouteRelX *relationx The extended relation.

  index_t index The index of this relation in the total.
  ++++++++++++++++++++++++++++++++++++++*/

static int deduplicate_by_id(RouteRelX *relationx,index_t index)
{
 static relation_t previd;

 if(index==0 || relationx->id!=previd)
   {
    previd=relationx->id;

    sortrelationsx->rnumber++;

    return(1);
   }

 return(0);
}


/*++++++++++++++++++++++++++++++++++++++
  Process the route relations and apply the information to the ways.

  RelationsX *relationsx The set of relations to process.

  WaysX *waysx The set of ways to update.
  ++++++++++++++++++++++++++++++++++++++*/

void ProcessRouteRelations(RelationsX *relationsx,WaysX *waysx)
{
 int i;

 /* Print the start message */

 printf("Processing Route Relations: Relations=0");
 fflush(stdout);

 /* Open the file and read through it */

 relationsx->rfd=ReOpenFile(relationsx->rfilename);

 for(i=0;i<relationsx->rnumber;i++)
   {
    FILESORT_VARINT padsize,size;
    RouteRelX relationx;
    way_t way;
    relation_t relation;
    void *pointer;

    ReadFile(relationsx->rfd,&padsize,FILESORT_VARSIZE);
    ReadFile(relationsx->rfd,&relationx,sizeof(RouteRelX));

    size=FILESORT_VARSIZE+sizeof(RouteRelX);

    do
      {
       ReadFile(relationsx->rfd,&way,sizeof(way_t));

//       if(way)
//          printf("Relation %d includes way %d\n",relationx.id,way);

       size+=sizeof(way_t);
      }
    while(way);

    do
      {
       ReadFile(relationsx->rfd,&relation,sizeof(relation_t));

//       if(relation)
//          printf("Relation %d includes relation %d\n",relationx.id,relation);

       size+=sizeof(relation_t);
      }
    while(relation);

    ReadFile(relationsx->rfd,&pointer,padsize-size);
   }

 CloseFile(relationsx->rfd);

 /* Print the final message */

 printf("\rProcessed Route Relations: Relations=%d  \n",relationsx->rnumber);
 fflush(stdout);
}
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/relationsx.c,v 1.1 2010-09-17 17:42:45 amb Exp $
3
4	Extended Relation data type functions.
5
6	Part of the Routino routing software.
7	****************/ /****************
8	This file Copyright 2010 Andrew M. Bishop
9
10	This program is free software: you can redistribute it and/or modify
11	it under the terms of the GNU Affero General Public License as published by
12	the Free Software Foundation, either version 3 of the License, or
13	(at your option) any later version.
14
15	This program is distributed in the hope that it will be useful,
16	but WITHOUT ANY WARRANTY; without even the implied warranty of
17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	GNU Affero General Public License for more details.
19
20	You should have received a copy of the GNU Affero General Public License
21	along with this program. If not, see <http://www.gnu.org/licenses/>.
22	***************************************/
23
24
25	#include <assert.h>
26	#include <stdlib.h>
27	#include <stdio.h>
28	#include <string.h>
29	#include <sys/stat.h>
30
31	#include "waysx.h"
32	#include "relationsx.h"
33
34	#include "files.h"
35	#include "functions.h"
36
37
38	/* Variables */
39
40	/+ The command line '--tmpdir' option or its default value. +/
41	extern char *option_tmpdirname;
42
43	/+ A temporary file-local variable for use by the sort functions. +/
44	static RelationsX *sortrelationsx;
45
46	/* Functions */
47
48	static int sort_by_id(RouteRelX a,RouteRelX b);
49	static int deduplicate_by_id(RouteRelX *relationx,index_t index);
50
51
52	/*++++++++++++++++++++++++++++++++++++++
53	Allocate a new relation list (create a new file or open an existing one).
54
55	RelationsX *NewRelationList Returns the relation list.
56
57	int append Set to 1 if the file is to be opened for appending (now or later).
58	++++++++++++++++++++++++++++++++++++++*/
59
60	RelationsX *NewRelationList(int append)
61	{
62	RelationsX *relationsx;
63
64	relationsx=(RelationsX*)calloc(1,sizeof(RelationsX));
65
66	assert(relationsx); /* Check calloc() worked */
67
68	relationsx->rfilename=(char*)malloc(strlen(option_tmpdirname)+32);
69
70	if(append)
71	sprintf(relationsx->rfilename,"%s/relationsx.route.input.tmp",option_tmpdirname);
72	else
73	sprintf(relationsx->rfilename,"%s/relationsx.route.%p.tmp",option_tmpdirname,relationsx);
74
75	if(append)
76	{
77	off_t size,position=0;
78
79	relationsx->rfd=AppendFile(relationsx->rfilename);
80
81	size=SizeFile(relationsx->rfilename);
82
83	while(position<size)
84	{
85	FILESORT_VARINT relationsize;
86
87	SeekFile(relationsx->rfd,position);
88	ReadFile(relationsx->rfd,&relationsize,FILESORT_VARSIZE);
89
90	relationsx->rxnumber++;
91	position+=relationsize+FILESORT_VARSIZE;
92	}
93
94	SeekFile(relationsx->rfd,size);
95	}
96	else
97	relationsx->rfd=OpenFile(relationsx->rfilename);
98
99	return(relationsx);
100	}
101
102
103	/*++++++++++++++++++++++++++++++++++++++
104	Free a relation list.
105
106	RelationsX *relationsx The list to be freed.
107
108	int keep Set to 1 if the file is to be kept.
109	++++++++++++++++++++++++++++++++++++++*/
110
111	void FreeRelationList(RelationsX *relationsx,int keep)
112	{
113	if(!keep)
114	DeleteFile(relationsx->rfilename);
115
116	free(relationsx->rfilename);
117
118	free(relationsx);
119	}
120
121
122	/*++++++++++++++++++++++++++++++++++++++
123	Append a single relation to an unsorted route relation list.
124
125	RelationsX* relationsx The set of relations to process.
126
127	relation_t id The ID of the relation.
128
129	allow_t routes The types of routes that this relation is for.
130
131	way_t *ways The array of ways that are members of the relation.
132
133	int nways The number of ways that are members of the relation.
134
135	relation_t *relations The array of relations that are members of the relation.
136
137	int nrelations The number of relations that are members of the relation.
138	++++++++++++++++++++++++++++++++++++++*/
139
140	void AppendRouteRelation(RelationsX* relationsx,relation_t id,allow_t routes,
141	way_t *ways,int nways,
142	relation_t *relations,int nrelations)
143	{
144	RouteRelX relationx;
145	FILESORT_VARINT size,padsize;
146	way_t zeroway=0;
147	relation_t zerorelation=0;
148	void *zeropointer=NULL;
149
150	relationx.id=id;
151	relationx.routes=routes;
152
153	size=sizeof(RouteRelX)+(nways+1)sizeof(way_t)+(nrelations+1)sizeof(relation_t);
154	padsize=sizeof(RouteRelX)((size+sizeof(RouteRelX)-1)/sizeof(RouteRelX));
155
156	WriteFile(relationsx->rfd,&padsize,FILESORT_VARSIZE);
157	WriteFile(relationsx->rfd,&relationx,sizeof(RouteRelX));
158
159	WriteFile(relationsx->rfd,ways ,nways*sizeof(way_t));
160	WriteFile(relationsx->rfd,&zeroway, sizeof(way_t));
161
162	WriteFile(relationsx->rfd,relations ,nrelations*sizeof(relation_t));
163	WriteFile(relationsx->rfd,&zerorelation, sizeof(relation_t));
164
165	WriteFile(relationsx->rfd,&zeropointer,padsize-size);
166
167	relationsx->rxnumber++;
168
169	assert(!(relationsx->rxnumber==0)); /* Zero marks the high-water mark for relations. */
170	}
171
172
173	/*++++++++++++++++++++++++++++++++++++++
174	Sort the list of relations.
175
176	RelationsX* relationsx The set of relations to process.
177	++++++++++++++++++++++++++++++++++++++*/
178
179	void SortRelationList(RelationsX* relationsx)
180	{
181	int rfd;
182
183	/* Print the start message */
184
185	printf("Sorting Relations");
186	fflush(stdout);
187
188	/* Close the file and re-open it (finished appending) */
189
190	CloseFile(relationsx->rfd);
191	relationsx->rfd=ReOpenFile(relationsx->rfilename);
192
193	DeleteFile(relationsx->rfilename);
194
195	rfd=OpenFile(relationsx->rfilename);
196
197	/* Sort the relations to allow removing duplicates */
198
199	sortrelationsx=relationsx;
200
201	filesort_vary(relationsx->rfd,rfd,(int ()(const void,const void))sort_by_id,(int ()(void*,index_t))deduplicate_by_id);
202
203	/* Close the files */
204
205	CloseFile(relationsx->rfd);
206	CloseFile(rfd);
207
208	/* Print the final message */
209
210	printf("\rSorted Relations: Relations=%d Duplicates=%d\n",relationsx->rxnumber,relationsx->rxnumber-relationsx->rnumber);
211	fflush(stdout);
212	}
213
214
215	/*++++++++++++++++++++++++++++++++++++++
216	Sort the relations into id order.
217
218	int sort_by_id Returns the comparison of the id fields.
219
220	RouteRelX *a The first extended relation.
221
222	RouteRelX *b The second extended relation.
223	++++++++++++++++++++++++++++++++++++++*/
224
225	static int sort_by_id(RouteRelX a,RouteRelX b)
226	{
227	relation_t a_id=a->id;
228	relation_t b_id=b->id;
229
230	if(a_id<b_id)
231	return(-1);
232	else if(a_id>b_id)
233	return(1);
234	else
235	return(0);
236	}
237
238
239	/*++++++++++++++++++++++++++++++++++++++
240	Deduplicate the extended relations using the id after sorting.
241
242	int deduplicate_by_id Return 1 if the value is to be kept, otherwise zero.
243
244	RouteRelX *relationx The extended relation.
245
246	index_t index The index of this relation in the total.
247	++++++++++++++++++++++++++++++++++++++*/
248
249	static int deduplicate_by_id(RouteRelX *relationx,index_t index)
250	{
251	static relation_t previd;
252
253	if(index==0 \|\| relationx->id!=previd)
254	{
255	previd=relationx->id;
256
257	sortrelationsx->rnumber++;
258
259	return(1);
260	}
261
262	return(0);
263	}
264
265
266	/*++++++++++++++++++++++++++++++++++++++
267	Process the route relations and apply the information to the ways.
268
269	RelationsX *relationsx The set of relations to process.
270
271	WaysX *waysx The set of ways to update.
272	++++++++++++++++++++++++++++++++++++++*/
273
274	void ProcessRouteRelations(RelationsX relationsx,WaysX waysx)
275	{
276	int i;
277
278	/* Print the start message */
279
280	printf("Processing Route Relations: Relations=0");
281	fflush(stdout);
282
283	/* Open the file and read through it */
284
285	relationsx->rfd=ReOpenFile(relationsx->rfilename);
286
287	for(i=0;i<relationsx->rnumber;i++)
288	{
289	FILESORT_VARINT padsize,size;
290	RouteRelX relationx;
291	way_t way;
292	relation_t relation;
293	void *pointer;
294
295	ReadFile(relationsx->rfd,&padsize,FILESORT_VARSIZE);
296	ReadFile(relationsx->rfd,&relationx,sizeof(RouteRelX));
297
298	size=FILESORT_VARSIZE+sizeof(RouteRelX);
299
300	do
301	{
302	ReadFile(relationsx->rfd,&way,sizeof(way_t));
303
304	// if(way)
305	// printf("Relation %d includes way %d\n",relationx.id,way);
306
307	size+=sizeof(way_t);
308	}
309	while(way);
310
311	do
312	{
313	ReadFile(relationsx->rfd,&relation,sizeof(relation_t));
314
315	// if(relation)
316	// printf("Relation %d includes relation %d\n",relationx.id,relation);
317
318	size+=sizeof(relation_t);
319	}
320	while(relation);
321
322	ReadFile(relationsx->rfd,&pointer,padsize-size);
323	}
324
325	CloseFile(relationsx->rfd);
326
327	/* Print the final message */
328
329	printf("\rProcessed Route Relations: Relations=%d \n",relationsx->rnumber);
330	fflush(stdout);
331	}