navit/navit/item.c

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <stdio.h>
#include <string.h>
#include <glib.h>
#include "coord.h"
#include "debug.h"
#include "item.h"
#include "map.h"
#include "transform.h"

struct item_name
{
        enum item_type item;
        char *name;
};

struct item_range item_range_all =
{ type_none, type_last };

struct default_flags
{
        enum item_type type;
        int flags;
};

struct item busy_item;

struct default_flags default_flags2[] =
{
{ type_street_nopass, AF_PBH },
{ type_street_0, AF_ALL },
{ type_street_1_city, AF_ALL },
{ type_street_2_city, AF_ALL },
{ type_street_3_city, AF_ALL },
{ type_street_4_city, AF_ALL },
{ type_highway_city, AF_MOTORIZED_FAST },
{ type_street_1_land, AF_ALL },
{ type_street_2_land, AF_ALL },
{ type_street_3_land, AF_ALL },
{ type_street_4_land, AF_ALL },
{ type_street_n_lanes, AF_MOTORIZED_FAST },
{ type_highway_land, AF_MOTORIZED_FAST },
{ type_ramp, AF_MOTORIZED_FAST },
{ type_roundabout, AF_ALL },
{ type_ferry, AF_ALL },
{ type_cycleway, AF_PBH },
{ type_track_paved, AF_ALL },
{ type_track_gravelled, AF_ALL },
{ type_track_unpaved, AF_ALL },
{ type_track_ground, AF_ALL },
{ type_track_grass, AF_ALL },
{ type_footway, AF_PBH },
{ type_living_street, AF_ALL },
{ type_street_service, AF_ALL },
{ type_bridleway, AF_PBH },
{ type_path, AF_PBH },
{ type_steps, AF_PBH },
{ type_street_pedestrian, AF_PBH }, };

struct item_name item_names[] =
{
#define ITEM2(x,y) ITEM(y)
#define ITEM(x) { type_##x, #x },
#include "item_def.h"
#undef ITEM2
#undef ITEM
                };

static GHashTable *default_flags_hash;

int *
item_get_default_flags(enum item_type type)
{
        if (!default_flags_hash)
        {
                int i;
                default_flags_hash = g_hash_table_new(NULL, NULL);
                for (i = 0; i < sizeof(default_flags2) / sizeof(struct default_flags); i++)
                {
                        g_hash_table_insert(default_flags_hash, (void *) (long) default_flags2[i].type, &default_flags2[i].flags);
                }
        }
        return g_hash_table_lookup(default_flags_hash, (void *) (long) type);
}

void item_cleanup(void)
{
        if (default_flags_hash)
                g_hash_table_destroy(default_flags_hash);
}

void item_coord_rewind(struct item *it)
{
        it->meth->item_coord_rewind(it->priv_data);
}

int item_coord_get(struct item *it, struct coord *c, int count)
{
        return it->meth->item_coord_get(it->priv_data, c, count);
}

int item_coord_set(struct item *it, struct coord *c, int count, enum change_mode mode)
{
        if (!it->meth->item_coord_set)
                return 0;
        return it->meth->item_coord_set(it->priv_data, c, count, mode);
}

int item_coord_get_within_selection(struct item *it, struct coord *c, int count, struct map_selection *sel)
{
        int i, ret = it->meth->item_coord_get(it->priv_data, c, count);
        struct coord_rect r;
        struct map_selection *curr;
        if (ret <= 0 || !sel)
                return ret;
        r.lu = c[0];
        r.rl = c[0];
        for (i = 1; i < ret; i++)
        {
                if (r.lu.x > c[i].x)
                        r.lu.x = c[i].x;
                if (r.rl.x < c[i].x)
                        r.rl.x = c[i].x;
                if (r.rl.y > c[i].y)
                        r.rl.y = c[i].y;
                if (r.lu.y < c[i].y)
                        r.lu.y = c[i].y;
        }
        curr = sel;
        while (curr)
        {
                struct coord_rect *sr = &curr->u.c_rect;
                if (r.lu.x <= sr->rl.x && r.rl.x >= sr->lu.x && r.lu.y >= sr->rl.y && r.rl.y <= sr->lu.y)
                        return ret;
                curr = curr->next;
        }
        return 0;
}

int item_coord_get_pro(struct item *it, struct coord *c, int count, enum projection to)
{
        int ret = item_coord_get(it, c, count);
        int i;
        enum projection from = map_projection(it->map);
        if (from != to)
                for (i = 0; i < count; i++)
                        transform_from_to(c + i, from, c + i, to);
        return ret;
}

int item_coord_is_node(struct item *it)
{
        if (it->meth->item_coord_is_node)
                return it->meth->item_coord_is_node(it->priv_data);
        return 0;
}

void item_attr_rewind(struct item *it)
{
        it->meth->item_attr_rewind(it->priv_data);
}

int item_attr_get(struct item *it, enum attr_type attr_type, struct attr *attr)
{
        if (it->meth)
        {
                return it->meth->item_attr_get(it->priv_data, attr_type, attr);
        }
        else
        {
                dbg(0, "not method found\n");
                return 0;
        }
}

int item_attr_set(struct item *it, struct attr *attr, enum change_mode mode)
{
        if (!it->meth->item_attr_set)
                return 0;
        return it->meth->item_attr_set(it->priv_data, attr, mode);
}

struct item * item_new(char *type, int zoom)
{
        struct item * it;

        it = g_new0(struct item, 1);

        /* FIXME evaluate arguments */

        return it;
}

enum item_type item_from_name(const char *name)
{
        int i;

        for (i = 0; i < sizeof(item_names) / sizeof(struct item_name); i++)
        {
                if (!strcmp(item_names[i].name, name))
                        return item_names[i].item;
        }
        return type_none;
}

char *
item_to_name(enum item_type item)
{
        int i;

        for (i = 0; i < sizeof(item_names) / sizeof(struct item_name); i++)
        {
                if (item_names[i].item == item)
                        return item_names[i].name;
        }
        return NULL;
}

struct item_hash
{
        GHashTable *h;
};

static guint item_hash_hash(gconstpointer key)
{
        const struct item *itm = key;
        gconstpointer hashkey = (gconstpointer) GINT_TO_POINTER(itm->id_hi ^ itm->id_lo ^ (GPOINTER_TO_INT(itm->map)));
        return g_direct_hash(hashkey);
}

static gboolean item_hash_equal(gconstpointer a, gconstpointer b)
{
        const struct item *itm_a = a;
        const struct item *itm_b = b;
        if (item_is_equal(*itm_a, *itm_b))
                return TRUE;
        return FALSE;
}

unsigned int item_id_hash(const void *key)
{
        const struct item_id *id = key;
        return id->id_hi ^ id->id_lo;
}

int item_id_equal(const void *a, const void *b)
{
        const struct item_id *id_a = a;
        const struct item_id *id_b = b;
        return (id_a->id_hi == id_b->id_hi && id_a->id_lo == id_b->id_lo);
}

struct item_hash *
item_hash_new(void)
{
        struct item_hash *ret=g_new(struct item_hash, 1);

        ret->h = g_hash_table_new_full(item_hash_hash, item_hash_equal, g_free, NULL);
        return ret;
}

void item_hash_insert(struct item_hash *h, struct item *item, void *val)
{
        struct item *hitem=g_new(struct item, 1);
        *hitem = *item;
        dbg(2, "inserting (0x%x,0x%x) into %p\n", item->id_hi, item->id_lo, h->h);
        g_hash_table_insert(h->h, hitem, val);
}

int item_hash_remove(struct item_hash *h, struct item *item)
{
        int ret;

        dbg(2, "removing (0x%x,0x%x) from %p\n", item->id_hi, item->id_lo, h->h);
        ret = g_hash_table_remove(h->h, item);
        dbg(2, "ret=%d\n", ret);

        return ret;
}

void *
item_hash_lookup(struct item_hash *h, struct item *item)
{
        return g_hash_table_lookup(h->h, item);
}

void item_hash_destroy(struct item_hash *h)
{
        g_hash_table_destroy(h->h);
        g_free(h);
}

int item_range_intersects_range(struct item_range *range1, struct item_range *range2)
{
        if (range1->max < range2->min)
                return 0;
        if (range1->min > range2->max)
                return 0;
        return 1;
}
int item_range_contains_item(struct item_range *range, enum item_type type)
{
        if (type >= range->min && type <= range->max)
                return 1;
        return 0;
}

void item_dump_attr_stdout(struct item *item, struct map *map)
{
        struct attr attr;
        dbg(0, "type=%s\n", item_to_name(item->type));
        while (item_attr_get(item, attr_any, &attr))
        {
                dbg(0, " %s='%s'", attr_to_name(attr.type), attr_to_text(&attr, map, 1));
                // dbg(0," %s\n", attr_to_name(attr.type));
        }
}

void item_dump_attr(struct item *item, struct map *map, FILE *out)
{
        struct attr attr;
        fprintf(out, "type=%s", item_to_name(item->type));
        while (item_attr_get(item, attr_any, &attr))
                fprintf(out, " %s='%s'", attr_to_name(attr.type), attr_to_text(&attr, map, 1));
}

void item_dump_filedesc(struct item *item, struct map *map, FILE *out)
{

        int i, count, max = 16384;
        struct coord *ca = g_alloca(sizeof(struct coord) * max);

        count = item_coord_get(item, ca, item->type < type_line ? 1 : max);
        if (item->type < type_line)
                fprintf(out, "mg:0x%x 0x%x ", ca[0].x, ca[0].y);
        item_dump_attr(item, map, out);
        fprintf(out, "\n");
        if (item->type >= type_line)
                for (i = 0; i < count; i++)
                        fprintf(out, "mg:0x%x 0x%x\n", ca[i].x, ca[i].y);
}
1	zoff99	2	/**
2			* Navit, a modular navigation system.
3			* Copyright (C) 2005-2008 Navit Team
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* version 2 as published by the Free Software Foundation.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the
16			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17			* Boston, MA 02110-1301, USA.
18			*/
19
20			#include <stdio.h>
21			#include <string.h>
22			#include <glib.h>
23			#include "coord.h"
24			#include "debug.h"
25			#include "item.h"
26			#include "map.h"
27			#include "transform.h"
28
29	zoff99	27	struct item_name
30			{
31			enum item_type item;
32			char *name;
33	zoff99	2	};
34
35	zoff99	27	struct item_range item_range_all =
36			{ type_none, type_last };
37	zoff99	2
38	zoff99	27	struct default_flags
39			{
40	zoff99	2	enum item_type type;
41			int flags;
42			};
43
44			struct item busy_item;
45
46	zoff99	27	struct default_flags default_flags2[] =
47			{
48			{ type_street_nopass, AF_PBH },
49			{ type_street_0, AF_ALL },
50			{ type_street_1_city, AF_ALL },
51			{ type_street_2_city, AF_ALL },
52			{ type_street_3_city, AF_ALL },
53			{ type_street_4_city, AF_ALL },
54			{ type_highway_city, AF_MOTORIZED_FAST },
55			{ type_street_1_land, AF_ALL },
56			{ type_street_2_land, AF_ALL },
57			{ type_street_3_land, AF_ALL },
58			{ type_street_4_land, AF_ALL },
59			{ type_street_n_lanes, AF_MOTORIZED_FAST },
60			{ type_highway_land, AF_MOTORIZED_FAST },
61			{ type_ramp, AF_MOTORIZED_FAST },
62			{ type_roundabout, AF_ALL },
63			{ type_ferry, AF_ALL },
64			{ type_cycleway, AF_PBH },
65			{ type_track_paved, AF_ALL },
66			{ type_track_gravelled, AF_ALL },
67			{ type_track_unpaved, AF_ALL },
68			{ type_track_ground, AF_ALL },
69			{ type_track_grass, AF_ALL },
70			{ type_footway, AF_PBH },
71			{ type_living_street, AF_ALL },
72			{ type_street_service, AF_ALL },
73			{ type_bridleway, AF_PBH },
74			{ type_path, AF_PBH },
75			{ type_steps, AF_PBH },
76			{ type_street_pedestrian, AF_PBH }, };
77	zoff99	2
78	zoff99	27	struct item_name item_names[] =
79			{
80	zoff99	2	#define ITEM2(x,y) ITEM(y)
81			#define ITEM(x) { type_##x, #x },
82			#include "item_def.h"
83			#undef ITEM2
84			#undef ITEM
85	zoff99	27	};
86	zoff99	2
87			static GHashTable *default_flags_hash;
88
89			int *
90			item_get_default_flags(enum item_type type)
91			{
92	zoff99	27	if (!default_flags_hash)
93			{
94	zoff99	2	int i;
95	zoff99	27	default_flags_hash = g_hash_table_new(NULL, NULL);
96			for (i = 0; i < sizeof(default_flags2) / sizeof(struct default_flags); i++)
97			{
98			g_hash_table_insert(default_flags_hash, (void *) (long) default_flags2[i].type, &default_flags2[i].flags);
99	zoff99	2	}
100			}
101	zoff99	27	return g_hash_table_lookup(default_flags_hash, (void *) (long) type);
102	zoff99	2	}
103
104	zoff99	27	void item_cleanup(void)
105	zoff99	2	{
106			if (default_flags_hash)
107			g_hash_table_destroy(default_flags_hash);
108			}
109
110	zoff99	27	void item_coord_rewind(struct item *it)
111	zoff99	2	{
112			it->meth->item_coord_rewind(it->priv_data);
113			}
114
115	zoff99	27	int item_coord_get(struct item it, struct coord c, int count)
116	zoff99	2	{
117			return it->meth->item_coord_get(it->priv_data, c, count);
118			}
119
120	zoff99	27	int item_coord_set(struct item it, struct coord c, int count, enum change_mode mode)
121	zoff99	2	{
122			if (!it->meth->item_coord_set)
123			return 0;
124			return it->meth->item_coord_set(it->priv_data, c, count, mode);
125			}
126
127	zoff99	27	int item_coord_get_within_selection(struct item it, struct coord c, int count, struct map_selection *sel)
128	zoff99	2	{
129	zoff99	27	int i, ret = it->meth->item_coord_get(it->priv_data, c, count);
130	zoff99	2	struct coord_rect r;
131			struct map_selection *curr;
132			if (ret <= 0 \|\| !sel)
133			return ret;
134	zoff99	27	r.lu = c[0];
135			r.rl = c[0];
136			for (i = 1; i < ret; i++)
137			{
138	zoff99	2	if (r.lu.x > c[i].x)
139	zoff99	27	r.lu.x = c[i].x;
140	zoff99	2	if (r.rl.x < c[i].x)
141	zoff99	27	r.rl.x = c[i].x;
142	zoff99	2	if (r.rl.y > c[i].y)
143	zoff99	27	r.rl.y = c[i].y;
144	zoff99	2	if (r.lu.y < c[i].y)
145	zoff99	27	r.lu.y = c[i].y;
146	zoff99	2	}
147	zoff99	27	curr = sel;
148			while (curr)
149			{
150			struct coord_rect *sr = &curr->u.c_rect;
151			if (r.lu.x <= sr->rl.x && r.rl.x >= sr->lu.x && r.lu.y >= sr->rl.y && r.rl.y <= sr->lu.y)
152	zoff99	2	return ret;
153	zoff99	27	curr = curr->next;
154	zoff99	2	}
155	zoff99	27	return 0;
156	zoff99	2	}
157
158	zoff99	27	int item_coord_get_pro(struct item it, struct coord c, int count, enum projection to)
159	zoff99	2	{
160	zoff99	27	int ret = item_coord_get(it, c, count);
161	zoff99	2	int i;
162	zoff99	27	enum projection from = map_projection(it->map);
163			if (from != to)
164			for (i = 0; i < count; i++)
165			transform_from_to(c + i, from, c + i, to);
166	zoff99	2	return ret;
167			}
168
169	zoff99	27	int item_coord_is_node(struct item *it)
170	zoff99	2	{
171			if (it->meth->item_coord_is_node)
172			return it->meth->item_coord_is_node(it->priv_data);
173			return 0;
174			}
175
176	zoff99	27	void item_attr_rewind(struct item *it)
177	zoff99	2	{
178			it->meth->item_attr_rewind(it->priv_data);
179			}
180
181	zoff99	27	int item_attr_get(struct item it, enum attr_type attr_type, struct attr attr)
182	zoff99	2	{
183			if (it->meth)
184			{
185			return it->meth->item_attr_get(it->priv_data, attr_type, attr);
186			}
187			else
188			{
189	zoff99	27	dbg(0, "not method found\n");
190	zoff99	2	return 0;
191			}
192			}
193
194	zoff99	27	int item_attr_set(struct item it, struct attr attr, enum change_mode mode)
195	zoff99	2	{
196			if (!it->meth->item_attr_set)
197			return 0;
198			return it->meth->item_attr_set(it->priv_data, attr, mode);
199			}
200
201			struct item * item_new(char *type, int zoom)
202			{
203			struct item * it;
204
205			it = g_new0(struct item, 1);
206
207			/* FIXME evaluate arguments */
208
209			return it;
210			}
211
212	zoff99	27	enum item_type item_from_name(const char *name)
213	zoff99	2	{
214			int i;
215
216	zoff99	27	for (i = 0; i < sizeof(item_names) / sizeof(struct item_name); i++)
217			{
218			if (!strcmp(item_names[i].name, name))
219	zoff99	2	return item_names[i].item;
220			}
221			return type_none;
222			}
223
224			char *
225			item_to_name(enum item_type item)
226			{
227			int i;
228
229	zoff99	27	for (i = 0; i < sizeof(item_names) / sizeof(struct item_name); i++)
230			{
231	zoff99	2	if (item_names[i].item == item)
232			return item_names[i].name;
233			}
234	zoff99	27	return NULL;
235	zoff99	2	}
236
237	zoff99	27	struct item_hash
238			{
239	zoff99	2	GHashTable *h;
240			};
241
242	zoff99	27	static guint item_hash_hash(gconstpointer key)
243	zoff99	2	{
244	zoff99	27	const struct item *itm = key;
245			gconstpointer hashkey = (gconstpointer) GINT_TO_POINTER(itm->id_hi ^ itm->id_lo ^ (GPOINTER_TO_INT(itm->map)));
246	zoff99	2	return g_direct_hash(hashkey);
247			}
248
249	zoff99	27	static gboolean item_hash_equal(gconstpointer a, gconstpointer b)
250	zoff99	2	{
251	zoff99	27	const struct item *itm_a = a;
252			const struct item *itm_b = b;
253	zoff99	2	if (item_is_equal(itm_a, itm_b))
254			return TRUE;
255			return FALSE;
256			}
257
258	zoff99	27	unsigned int item_id_hash(const void *key)
259	zoff99	2	{
260	zoff99	27	const struct item_id *id = key;
261			return id->id_hi ^ id->id_lo;
262	zoff99	2	}
263
264	zoff99	27	int item_id_equal(const void a, const void b)
265	zoff99	2	{
266	zoff99	27	const struct item_id *id_a = a;
267			const struct item_id *id_b = b;
268	zoff99	2	return (id_a->id_hi == id_b->id_hi && id_a->id_lo == id_b->id_lo);
269			}
270
271			struct item_hash *
272			item_hash_new(void)
273			{
274			struct item_hash *ret=g_new(struct item_hash, 1);
275
276	zoff99	27	ret->h = g_hash_table_new_full(item_hash_hash, item_hash_equal, g_free, NULL);
277	zoff99	2	return ret;
278			}
279
280	zoff99	27	void item_hash_insert(struct item_hash h, struct item item, void *val)
281	zoff99	2	{
282			struct item *hitem=g_new(struct item, 1);
283	zoff99	27	hitem = item;
284			dbg(2, "inserting (0x%x,0x%x) into %p\n", item->id_hi, item->id_lo, h->h);
285	zoff99	2	g_hash_table_insert(h->h, hitem, val);
286			}
287
288	zoff99	27	int item_hash_remove(struct item_hash h, struct item item)
289	zoff99	2	{
290			int ret;
291
292	zoff99	27	dbg(2, "removing (0x%x,0x%x) from %p\n", item->id_hi, item->id_lo, h->h);
293			ret = g_hash_table_remove(h->h, item);
294			dbg(2, "ret=%d\n", ret);
295	zoff99	2
296			return ret;
297			}
298
299			void *
300			item_hash_lookup(struct item_hash h, struct item item)
301			{
302			return g_hash_table_lookup(h->h, item);
303			}
304
305	zoff99	27	void item_hash_destroy(struct item_hash *h)
306	zoff99	2	{
307			g_hash_table_destroy(h->h);
308			g_free(h);
309			}
310
311	zoff99	27	int item_range_intersects_range(struct item_range range1, struct item_range range2)
312	zoff99	2	{
313			if (range1->max < range2->min)
314			return 0;
315			if (range1->min > range2->max)
316			return 0;
317			return 1;
318			}
319	zoff99	27	int item_range_contains_item(struct item_range *range, enum item_type type)
320	zoff99	2	{
321			if (type >= range->min && type <= range->max)
322			return 1;
323			return 0;
324			}
325
326	zoff99	27	void item_dump_attr_stdout(struct item item, struct map map)
327	zoff99	2	{
328			struct attr attr;
329	zoff99	27	dbg(0, "type=%s\n", item_to_name(item->type));
330	zoff99	2	while (item_attr_get(item, attr_any, &attr))
331			{
332	zoff99	27	dbg(0, " %s='%s'", attr_to_name(attr.type), attr_to_text(&attr, map, 1));
333	zoff99	2	// dbg(0," %s\n", attr_to_name(attr.type));
334			}
335			}
336
337	zoff99	27	void item_dump_attr(struct item item, struct map map, FILE *out)
338	zoff99	2	{
339			struct attr attr;
340	zoff99	27	fprintf(out, "type=%s", item_to_name(item->type));
341			while (item_attr_get(item, attr_any, &attr))
342			fprintf(out, " %s='%s'", attr_to_name(attr.type), attr_to_text(&attr, map, 1));
343	zoff99	2	}
344
345	zoff99	27	void item_dump_filedesc(struct item item, struct map map, FILE *out)
346	zoff99	2	{
347
348	zoff99	27	int i, count, max = 16384;
349			struct coord ca = g_alloca(sizeof(struct coord) max);
350	zoff99	2
351	zoff99	27	count = item_coord_get(item, ca, item->type < type_line ? 1 : max);
352			if (item->type < type_line)
353			fprintf(out, "mg:0x%x 0x%x ", ca[0].x, ca[0].y);
354	zoff99	2	item_dump_attr(item, map, out);
355	zoff99	27	fprintf(out, "\n");
356	zoff99	2	if (item->type >= type_line)
357	zoff99	27	for (i = 0; i < count; i++)
358			fprintf(out, "mg:0x%x 0x%x\n", ca[i].x, ca[i].y);
359	zoff99	2	}