trunk/src/ways.h

/***************************************
 $Header: /home/amb/CVS/routino/src/ways.h,v 1.9 2009-01-21 19:35:52 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 uint8_t waytype_t;

/*+ The different types of a way. +*/
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_Service    =8,
  Way_Track      =9,
  Way_Bridleway  =10,
  Way_Cycleway   =11,
  Way_Footway    =12,
  Way_Unknown    =15,

  Way_OneWay     =16,
  Way_Roundabout =32
 }
 WayType;

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


/*+ A way type identifier. +*/
typedef uint8_t wayallow_t;

/*+ The different allowed traffic on a way. +*/
typedef enum _AllowType
 {
  Allow_Foot      =  1,
  Allow_Bicycle   =  2,
  Allow_Horse     =  4,
  Allow_Motorbike =  8,
  Allow_Motorcar  = 16,
  Allow_PSV       = 32,
  Allow_Goods     = 64,
  Allow_HGV       =128,
  Allow_ALL       =255
 }
 AllowType;


/* 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. +*/
 waytype_t  type;               /*+ The type of the way. +*/
 wayallow_t allow;              /*+ The type of traffic allowed on 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);

AllowType AllowedType(const char *transport);

speed_t WaySpeed(Way *way);

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

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


#endif /* WAYS_H */
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/ways.h,v 1.9 2009-01-21 19:35:52 amb Exp $
3
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	/+ The array size increment for ways. +/
36	#define INCREMENT_WAYS 256*1024
37
38
39	/* 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	/+ A way type identifier. +/
49	typedef uint8_t waytype_t;
50
51	/+ The different types of a way. +/
52	typedef enum _WayType
53	{
54	Way_Motorway =1,
55	Way_Trunk =2,
56	Way_Primary =3,
57	Way_Tertiary =4,
58	Way_Secondary =5,
59	Way_Unclassfied=6,
60	Way_Residential=7,
61	Way_Service =8,
62	Way_Track =9,
63	Way_Bridleway =10,
64	Way_Cycleway =11,
65	Way_Footway =12,
66	Way_Unknown =15,
67
68	Way_OneWay =16,
69	Way_Roundabout =32
70	}
71	WayType;
72
73	#define Way_TYPE(xx) ((xx)&0x1f)
74
75
76	/+ A way type identifier. +/
77	typedef uint8_t wayallow_t;
78
79	/+ The different allowed traffic on a way. +/
80	typedef enum _AllowType
81	{
82	Allow_Foot = 1,
83	Allow_Bicycle = 2,
84	Allow_Horse = 4,
85	Allow_Motorbike = 8,
86	Allow_Motorcar = 16,
87	Allow_PSV = 32,
88	Allow_Goods = 64,
89	Allow_HGV =128,
90	Allow_ALL =255
91	}
92	AllowType;
93
94
95	/* Data structures */
96
97
98	/+ A structure containing a single way. +/
99	typedef struct _Way
100	{
101	way_t id; /+ The way identifier. +/
102	uint32_t name; /+ An offset of the name of the way in the ways array. +/
103	speed_t limit; /+ The defined speed limit on the way. +/
104	waytype_t type; /+ The type of the way. +/
105	wayallow_t allow; /+ The type of traffic allowed on the way. +/
106	}
107	Way;
108
109	/+ A structure containing a set of ways (mmap format). +/
110	typedef struct _Ways
111	{
112	uint32_t number; /+ How many entries are used? +/
113	#ifdef NBINS_WAYS
114	uint32_t offset[NBINS_WAYS+1]; /+ An offset to the first entry in each bin. +/
115	#endif
116	Way ways[1]; /*+ An array of ways whose size is not limited to 1
117	(i.e. may overflow the end of this structure). +*/
118	}
119	Ways;
120
121	/+ A structure containing a set of ways (memory format). +/
122	typedef struct _WaysMem
123	{
124	uint32_t alloced; /+ How many entries are allocated? +/
125	uint32_t number; /+ How many entries are used? +/
126	uint32_t number_str; /+ How many name entries are used? +/
127	uint32_t sorted; /+ Is the data sorted and therefore searchable? +/
128
129	Ways ways; /+ The real data +*/
130	char *names; /+ An array of names. +*/
131	}
132	WaysMem;
133
134
135	/* Functions */
136
137
138	WaysMem *NewWayList(void);
139
140	Ways LoadWayList(const char filename);
141	Ways SaveWayList(WaysMem ways,const char *filename);
142
143	Way FindWay(Ways ways,way_t id);
144
145	Way AppendWay(WaysMem ways,way_t id,const char *name);
146
147	void SortWayList(WaysMem *ways);
148
149	WayType TypeOfWay(const char *type);
150
151	AllowType AllowedType(const char *transport);
152
153	speed_t WaySpeed(Way *way);
154
155	#define LookupWay(xxx,yyy) (&xxx->ways[yyy])
156
157	#define WayName(xxx,yyy) ((char*)&xxx->ways[yyy->name])
158
159
160	#endif /* WAYS_H */