trunk/src/ways.h

/***************************************
 $Header: /home/amb/CVS/routino/src/ways.h,v 1.5 2009-01-11 09:33:59 amb Exp $

 A header file for the ways.
 ******************/ /******************
 Written by Andrew M. Bishop

 This file Copyright 2009 Andrew M. Bishop
 It may be distributed under the GNU Public License, version 2, or
 any higher version.  See section COPYING of the GNU Public license
 for conditions under which this file may be redistributed.
 ***************************************/


#ifndef WAYS_H
#define WAYS_H    /*+ To stop multiple inclusions. +*/

#include <stdint.h>


/* Constants */


#if 1 /* set to 0 to use a flat array, 1 for indexed. */

/*+ The number of bins for ways. +*/
#define NBINS_WAYS 1024

#else

#undef NBINS_WAYS

#endif

/*+ The array size increment for ways. +*/
#define INCREMENT_WAYS 256*1024


/* Simple Types */


/*+ A way identifier. +*/
typedef uint32_t way_t;

/*+ The speed limit of the way. +*/
typedef uint8_t speed_t;

/*+ A way type identifier. +*/
typedef uint16_t waytype_t;

typedef enum _WayType
 {
  Way_Motorway   =1,
  Way_Trunk      =2,
  Way_Primary    =3,
  Way_Tertiary   =4,
  Way_Secondary  =5,
  Way_Unclassfied=6,
  Way_Residential=7,

  Way_HighestRoutable=7,

  Way_Service    =8,
  Way_Track      =9,
  Way_Bridleway  =10,
  Way_Cycleway   =11,
  Way_Footway    =12,
  Way_Unknown    =15,
 }
 WayType;

#define Way_TYPE(xx) ((xx)&0x0f)

#define Way_ONEWAY       16
#define Way_ROUNDABOUT   32
#define Way_NOTROUTABLE 128


/* Data structures */


/*+ A structure containing a single way. +*/
typedef struct _Way
{
 way_t     id;                  /*+ The way identifier. +*/
 uint32_t  name;                /*+ An offset of the name of the way in the ways array. +*/
 speed_t   limit;               /*+ The defined speed limit on the way. +*/
 speed_t   speed;               /*+ The assumed speed limit on the way. +*/
 waytype_t type;                /*+ The type of the way. +*/
}
 Way;

/*+ A structure containing a set of ways (mmap format). +*/
typedef struct _Ways
{
 uint32_t number;               /*+ How many entries are used? +*/
#ifdef NBINS_WAYS
 uint32_t offset[NBINS_WAYS+1]; /*+ An offset to the first entry in each bin. +*/
#endif
 Way      ways[1];              /*+ An array of ways whose size is not limited to 1
                                    (i.e. may overflow the end of this structure). +*/
}
 Ways;

/*+ A structure containing a set of ways (memory format). +*/
typedef struct _WaysMem
{
 uint32_t alloced;              /*+ How many entries are allocated? +*/
 uint32_t number;               /*+ How many entries are used? +*/
 uint32_t number_str;           /*+ How many name entries are used? +*/
 uint32_t sorted;               /*+ Is the data sorted and therefore searchable? +*/

 Ways    *ways;                 /*+ The real data +*/
 char   **names;                /*+ An array of names. +*/
}
 WaysMem;


/* Functions */


WaysMem *NewWayList(void);

Ways *LoadWayList(const char *filename);
Ways *SaveWayList(WaysMem *ways,const char *filename);

Way *FindWay(Ways *ways,way_t id);

Way *AppendWay(WaysMem *ways,way_t id,const char *name);

void SortWayList(WaysMem *ways);

WayType TypeOfWay(const char *type);

#define LookupWay(xxx,yyy) (&xxx->ways[yyy])

#define WayName(xxx,yyy) ((char*)&xxx->ways[yyy->name])


#endif /* WAYS_H */
1	amb	21	/***************************************
2	amb	32	$Header: /home/amb/CVS/routino/src/ways.h,v 1.5 2009-01-11 09:33:59 amb Exp $
3	amb	21
4			A header file for the ways.
5			****************/ /****************
6			Written by Andrew M. Bishop
7
8			This file Copyright 2009 Andrew M. Bishop
9			It may be distributed under the GNU Public License, version 2, or
10			any higher version. See section COPYING of the GNU Public license
11			for conditions under which this file may be redistributed.
12			***************************************/
13
14
15			#ifndef WAYS_H
16			#define WAYS_H /+ To stop multiple inclusions. +/
17
18			#include <stdint.h>
19
20
21			/* Constants */
22
23
24			#if 1 /* set to 0 to use a flat array, 1 for indexed. */
25
26			/+ The number of bins for ways. +/
27			#define NBINS_WAYS 1024
28
29			#else
30
31			#undef NBINS_WAYS
32
33			#endif
34
35	amb	27	/+ The array size increment for ways. +/
36			#define INCREMENT_WAYS 256*1024
37	amb	21
38	amb	27
39	amb	21	/* Simple Types */
40
41
42			/+ A way identifier. +/
43			typedef uint32_t way_t;
44
45			/+ The speed limit of the way. +/
46			typedef uint8_t speed_t;
47
48	amb	30	/+ A way type identifier. +/
49			typedef uint16_t waytype_t;
50	amb	21
51	amb	30	typedef enum _WayType
52			{
53			Way_Motorway =1,
54			Way_Trunk =2,
55			Way_Primary =3,
56			Way_Tertiary =4,
57			Way_Secondary =5,
58			Way_Unclassfied=6,
59			Way_Residential=7,
60
61			Way_HighestRoutable=7,
62
63			Way_Service =8,
64			Way_Track =9,
65			Way_Bridleway =10,
66			Way_Cycleway =11,
67			Way_Footway =12,
68			Way_Unknown =15,
69			}
70			WayType;
71
72			#define Way_TYPE(xx) ((xx)&0x0f)
73
74			#define Way_ONEWAY 16
75			#define Way_ROUNDABOUT 32
76			#define Way_NOTROUTABLE 128
77
78
79	amb	21	/* Data structures */
80
81
82			/+ A structure containing a single way. +/
83			typedef struct _Way
84			{
85			way_t id; /+ The way identifier. +/
86	amb	30	uint32_t name; /+ An offset of the name of the way in the ways array. +/
87	amb	21	speed_t limit; /+ The defined speed limit on the way. +/
88			speed_t speed; /+ The assumed speed limit on the way. +/
89	amb	30	waytype_t type; /+ The type of the way. +/
90	amb	21	}
91			Way;
92
93			/+ A structure containing a set of ways (mmap format). +/
94			typedef struct _Ways
95			{
96	amb	26	uint32_t number; /+ How many entries are used? +/
97	amb	21	#ifdef NBINS_WAYS
98	amb	26	uint32_t offset[NBINS_WAYS+1]; /+ An offset to the first entry in each bin. +/
99	amb	21	#endif
100	amb	26	Way ways[1]; /*+ An array of ways whose size is not limited to 1
101	amb	21	(i.e. may overflow the end of this structure). +*/
102			}
103			Ways;
104
105			/+ A structure containing a set of ways (memory format). +/
106			typedef struct _WaysMem
107			{
108			uint32_t alloced; /+ How many entries are allocated? +/
109			uint32_t number; /+ How many entries are used? +/
110			uint32_t number_str; /+ How many name entries are used? +/
111			uint32_t sorted; /+ Is the data sorted and therefore searchable? +/
112
113			Ways ways; /+ The real data +*/
114			char *names; /+ An array of names. +*/
115			}
116			WaysMem;
117
118
119			/* Functions */
120
121
122			WaysMem *NewWayList(void);
123
124			Ways LoadWayList(const char filename);
125			Ways SaveWayList(WaysMem ways,const char *filename);
126
127			Way FindWay(Ways ways,way_t id);
128
129	amb	30	Way AppendWay(WaysMem ways,way_t id,const char *name);
130	amb	21
131			void SortWayList(WaysMem *ways);
132
133	amb	30	WayType TypeOfWay(const char *type);
134	amb	21
135	amb	32	#define LookupWay(xxx,yyy) (&xxx->ways[yyy])
136	amb	21
137	amb	32	#define WayName(xxx,yyy) ((char*)&xxx->ways[yyy->name])
138
139
140	amb	21	#endif /* WAYS_H */