trunk/src/ways.h

/***************************************
 $Header: /home/amb/CVS/routino/src/ways.h,v 1.18 2009-01-27 18:22:37 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 */


/*+ The array size increment for ways - expect ~1,000,000 ways. +*/
#define INCREMENT_WAYS 256*1024


/* Simple Types */


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

/*+ The type of a way. +*/
typedef uint8_t waytype_t;

/*+ The different types of a way. +*/
typedef enum _Highway
 {
  Way_Motorway    = 1,
  Way_Trunk       = 2,
  Way_Primary     = 3,
  Way_Secondary   = 4,
  Way_Tertiary    = 5,
  Way_Unclassified= 6,
  Way_Residential = 7,
  Way_Service     = 8,
  Way_Track       = 9,
  Way_Bridleway   =10,
  Way_Cycleway    =11,
  Way_Footway     =12,

  Way_Unknown     =13,

  Way_OneWay      =16,
  Way_Roundabout  =32
 }
 Highway;

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


/*+ The type of a method of transport. +*/
typedef uint8_t transport_t;

/*+ The different methods of transport. +*/
typedef enum _Transport
 {
  Transport_None      = 0,

  Transport_Foot      = 1,
  Transport_Bicycle   = 2,
  Transport_Horse     = 3,
  Transport_Motorbike = 4,
  Transport_Motorcar  = 5,
  Transport_Goods     = 6,
  Transport_HGV       = 7,
  Transport_PSV       = 8
 }
 Transport;


/*+ The allowed traffic on a way. +*/
typedef uint8_t wayallow_t;

/*+ The different allowed traffic on a way. +*/
typedef enum _Allowed
 {
  Allow_Foot      =1<<(Transport_Foot     -1),
  Allow_Bicycle   =1<<(Transport_Bicycle  -1),
  Allow_Horse     =1<<(Transport_Horse    -1),
  Allow_Motorbike =1<<(Transport_Motorbike-1),
  Allow_Motorcar  =1<<(Transport_Motorcar -1),
  Allow_Goods     =1<<(Transport_Goods    -1),
  Allow_HGV       =1<<(Transport_HGV      -1),
  Allow_PSV       =1<<(Transport_PSV      -1),

  Allow_ALL       =255
 }
 Allowed;


/* Data structures */


/*+ A structure containing a single way. +*/
typedef struct _Way
{
 uint32_t   name;               /*+ The offset of the name of the way in the names 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;

/*+ An extended structure containing a single way. +*/
typedef struct _WayEx
{
 uint32_t   index;              /*+ The index of the way. +*/
 char      *name;               /*+ The name of the way. +*/

 Way        way;                /*+ The real Way data. +*/
}
 WayEx;

/*+ A structure containing a set of ways (mmap format). +*/
typedef struct _Ways
{
 uint32_t number;               /*+ How many entries are used? +*/

 Way     *ways;                 /*+ An array of ways. */
 char    *names;                /*+ An array of characters containing the names. +*/

 void    *data;                 /*+ The memory mapped data. +*/
}
 Ways;

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

 WayEx   *xdata;                /*+ The extended data for the Ways. +*/
 char    *names;                /*+ The array containing all the names. +*/
}
 WaysMem;


/* Functions */


WaysMem *NewWayList(void);

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

void DropWayList(Ways *ways);

Way *AppendWay(WaysMem *waysmem,const char *name);

void SortWayList(WaysMem *waysmem);

Highway HighwayType(const char *highway);
Transport TransportType(const char *transport);

const char *HighwayName(Highway highway);
const char *TransportName(Transport transport);

const char *HighwayList(void);
const char *TransportList(void);

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

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

#define WayName(xxx,yyy) (&(xxx)->names[(yyy)->name])


#endif /* WAYS_H */
1	/***************************************
2	$Header: /home/amb/CVS/routino/src/ways.h,v 1.18 2009-01-27 18:22:37 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	/+ The array size increment for ways - expect ~1,000,000 ways. +/
25	#define INCREMENT_WAYS 256*1024
26
27
28	/* Simple Types */
29
30
31	/+ The speed limit of the way. +/
32	typedef uint8_t speed_t;
33
34	/+ The type of a way. +/
35	typedef uint8_t waytype_t;
36
37	/+ The different types of a way. +/
38	typedef enum _Highway
39	{
40	Way_Motorway = 1,
41	Way_Trunk = 2,
42	Way_Primary = 3,
43	Way_Secondary = 4,
44	Way_Tertiary = 5,
45	Way_Unclassified= 6,
46	Way_Residential = 7,
47	Way_Service = 8,
48	Way_Track = 9,
49	Way_Bridleway =10,
50	Way_Cycleway =11,
51	Way_Footway =12,
52
53	Way_Unknown =13,
54
55	Way_OneWay =16,
56	Way_Roundabout =32
57	}
58	Highway;
59
60	#define HIGHWAY(xx) ((xx)&0x0f)
61
62
63	/+ The type of a method of transport. +/
64	typedef uint8_t transport_t;
65
66	/+ The different methods of transport. +/
67	typedef enum _Transport
68	{
69	Transport_None = 0,
70
71	Transport_Foot = 1,
72	Transport_Bicycle = 2,
73	Transport_Horse = 3,
74	Transport_Motorbike = 4,
75	Transport_Motorcar = 5,
76	Transport_Goods = 6,
77	Transport_HGV = 7,
78	Transport_PSV = 8
79	}
80	Transport;
81
82
83	/+ The allowed traffic on a way. +/
84	typedef uint8_t wayallow_t;
85
86	/+ The different allowed traffic on a way. +/
87	typedef enum _Allowed
88	{
89	Allow_Foot =1<<(Transport_Foot -1),
90	Allow_Bicycle =1<<(Transport_Bicycle -1),
91	Allow_Horse =1<<(Transport_Horse -1),
92	Allow_Motorbike =1<<(Transport_Motorbike-1),
93	Allow_Motorcar =1<<(Transport_Motorcar -1),
94	Allow_Goods =1<<(Transport_Goods -1),
95	Allow_HGV =1<<(Transport_HGV -1),
96	Allow_PSV =1<<(Transport_PSV -1),
97
98	Allow_ALL =255
99	}
100	Allowed;
101
102
103	/* Data structures */
104
105
106	/+ A structure containing a single way. +/
107	typedef struct _Way
108	{
109	uint32_t name; /+ The offset of the name of the way in the names array. +/
110	speed_t limit; /+ The defined speed limit on the way. +/
111	waytype_t type; /+ The type of the way. +/
112	wayallow_t allow; /+ The type of traffic allowed on the way. +/
113	}
114	Way;
115
116	/+ An extended structure containing a single way. +/
117	typedef struct _WayEx
118	{
119	uint32_t index; /+ The index of the way. +/
120	char name; /+ The name of the way. +*/
121
122	Way way; /+ The real Way data. +/
123	}
124	WayEx;
125
126	/+ A structure containing a set of ways (mmap format). +/
127	typedef struct _Ways
128	{
129	uint32_t number; /+ How many entries are used? +/
130
131	Way ways; /+ An array of ways. */
132	char names; /+ An array of characters containing the names. +*/
133
134	void data; /+ The memory mapped data. +*/
135	}
136	Ways;
137
138	/+ A structure containing a set of ways (memory format). +/
139	typedef struct _WaysMem
140	{
141	uint32_t sorted; /+ Is the data sorted? +/
142	uint32_t alloced; /+ How many entries are allocated? +/
143	uint32_t number; /+ How many entries are used? +/
144	uint32_t length; /+ How long is the string of name entries? +/
145
146	WayEx xdata; /+ The extended data for the Ways. +*/
147	char names; /+ The array containing all the names. +*/
148	}
149	WaysMem;
150
151
152	/* Functions */
153
154
155	WaysMem *NewWayList(void);
156
157	Ways LoadWayList(const char filename);
158	Ways SaveWayList(WaysMem waysmem,const char *filename);
159
160	void DropWayList(Ways *ways);
161
162	Way AppendWay(WaysMem waysmem,const char *name);
163
164	void SortWayList(WaysMem *waysmem);
165
166	Highway HighwayType(const char *highway);
167	Transport TransportType(const char *transport);
168
169	const char *HighwayName(Highway highway);
170	const char *TransportName(Transport transport);
171
172	const char *HighwayList(void);
173	const char *TransportList(void);
174
175	#define LookupWay(xxx,yyy) (&(xxx)->ways[yyy])
176
177	#define IndexWay(xxx,yyy) ((yyy)-&(xxx)->ways[0])
178
179	#define WayName(xxx,yyy) (&(xxx)->names[(yyy)->name])
180
181
182	#endif /* WAYS_H */