navit/navit/mapset.c

/**
 * ZANavi, Zoff Android Navigation system.
 * Copyright (C) 2011-2013 Zoff <zoff@zoff.cc>
 *
 * 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.
 */

/**
 * 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.
 */

/** @file
 * 
 * @brief Contains code used for loading more than one map
 *
 * The code in this file introduces "mapsets", which are collections of several maps.
 * This enables navit to operate on more than one map at once. See map.c / map.h to learn
 * how maps are handled.
 */

#include <string.h>
#include <glib.h>
#include <glib/gprintf.h>
#include "debug.h"
#include "item.h"
#include "mapset.h"
#include "projection.h"
#include "map.h"

/**
 * @brief A mapset
 *
 * This structure holds a complete mapset
 */
struct mapset
{
        GList *maps; /**< Linked list of all the maps in the mapset */
};

struct attr_iter
{
        GList *last;
};

/**
 * @brief Creates a new, empty mapset
 *
 * @return The new mapset 
 */
struct mapset *mapset_new(struct attr *parent, struct attr **attrs)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct mapset *ms;

        ms=g_new0(struct mapset, 1);

#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:leave\n");
#endif

        return ms;
}

struct attr_iter *
mapset_attr_iter_new(void)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
return g_new0(struct attr_iter, 1);
}

void mapset_attr_iter_destroy(struct attr_iter *iter)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        g_free(iter);
}

/**
 * @brief Adds a map to a mapset
 *
 * @param ms The mapset to add the map to
 * @param m The map to be added
 */
int mapset_add_attr(struct mapset *ms, struct attr *attr)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        switch (attr->type)
        {
                case attr_map:
                        ms->maps = g_list_append(ms->maps, attr->u.map);
                        map_ref(attr->u.map);
                        return 1;
                default:
                        return 0;
        }
}

int mapset_add_attr_name(struct mapset *ms, struct attr *attr)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct attr map_name;

        dbg(0, "****** ADD MAP from sdcard ******");
        switch (attr->type)
        {
                case attr_map:
                        ms->maps = g_list_append(ms->maps, attr->u.map);
                        map_ref(attr->u.map);

                        struct map *m;
                        m=g_new0(struct map, 1);
                        m = attr->u.map;
                        struct attr *map_file_name = attr_search(m->attrs, NULL, attr_data);
                        map_name.type = attr_name;
                        map_name.u.str = g_strconcat("_ms_sdcard_map:", map_file_name->u.str, NULL);

                        dbg(0, "====== map name1=%s", map_name.u.str);
                        map_set_attr(attr->u.map, &map_name);

                        return 1;
                default:
                        return 0;
        }
}

int mapset_add_attr_name_str(struct mapset *ms, struct attr *attr, char *map_name_str)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct attr map_name;

        dbg(0, "****** ADD MAP from sdcard - with name str ******");
        switch (attr->type)
        {
                case attr_map:
                        ms->maps = g_list_append(ms->maps, attr->u.map);
                        map_ref(attr->u.map);

                        struct map *m;
                        m=g_new0(struct map, 1);
                        m = attr->u.map;
                        struct attr *map_file_name = attr_search(m->attrs, NULL, attr_data);
                        map_name.type = attr_name;
                        map_name.u.str = g_strconcat("_ms_sdcard_map:", map_name_str, NULL);

                        dbg(0, "====== map name2=%s", map_name.u.str);
                        map_set_attr(attr->u.map, &map_name);

                        return 1;
                default:
                        return 0;
        }
}

int mapset_remove_attr(struct mapset *ms, struct attr *attr)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        switch (attr->type)
        {
                case attr_map:
                        ms->maps = g_list_remove(ms->maps, attr->u.map);
                        return 1;
                default:
                        return 0;
        }
}

int mapset_get_attr(struct mapset *ms, enum attr_type type, struct attr *attr, struct attr_iter *iter)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        GList *map;
        map = ms->maps;
        attr->type = type;
        switch (type)
        {
                case attr_map:
                        while (map)
                        {
                                if (!iter || iter->last == g_list_previous(map))
                                {
                                        attr->u.map = map->data;
                                        if (iter)
                                                iter->last = map;
                                        return 1;
                                }
                                map = g_list_next(map);
                        }
                        break;
                default:
                        break;
        }
        return 0;
}

#if 0
static void mapset_maps_free(struct mapset *ms)
{
        /* todo */
}
#endif

/**
 * @brief Destroys a mapset. 
 *
 * This destroys a mapset. Please note that it does not touch the contained maps
 * in any way.
 *
 * @param ms The mapset to be destroyed
 */
void mapset_destroy(struct mapset *ms)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        GList *map;
        map = ms->maps;

        while (map)
        {
                map_destroy(map->data);
                map = g_list_next(map);
        }
        g_free(ms);
}

/**
 * @brief Handle for a mapset in use
 *
 * This struct is used for a mapset that is in use. With this it is possible to iterate
 * all maps in a mapset.
 */
struct mapset_handle
{
        GList *l; /**< Pointer to the current (next) map */
};

/**
 * @brief Returns a new handle for a mapset
 *
 * This returns a new handle for an existing mapset. The new handle points to the first
 * map in the set.
 *
 * @param ms The mapset to get a handle of
 * @return The new mapset handle
 */
struct mapset_handle *
mapset_open(struct mapset *ms)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct mapset_handle *ret = NULL;
        if (ms)
        {
                ret=g_new(struct mapset_handle, 1);
                ret->l = ms->maps;
        }

        return ret;
}

/**
 * @brief Gets the next map from a mapset handle
 *
 * If you set active to true, this function will not return any maps that
 * have the attr_active attribute associated with them and set to false.
 *
 * @param msh The mapset handle to get the next map of
 * @param active Set to true to only get active maps (See description)
 * @return The next map
 */
struct map * mapset_next(struct mapset_handle *msh, int active)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct map *ret;
        struct attr active_attr;

        for (;;)
        {
                if (!msh || !msh->l)
                {
                        return NULL;
                }

                ret = msh->l->data;
                msh->l = g_list_next(msh->l);

                if (!active)
                {
                        return ret;
                }

                if (active == 2 && map_get_attr(ret, attr_route_active, &active_attr, NULL))
                {
                        if (active_attr.u.num)
                                return ret;
                        else
                                continue;
                }

                if (active == 3 && map_get_attr(ret, attr_search_active, &active_attr, NULL))
                {
                        if (active_attr.u.num)
                                return ret;
                        else
                                continue;
                }

                if (!map_get_attr(ret, attr_active, &active_attr, NULL))
                        return ret;

                if (active_attr.u.num)
                        return ret;
        }
}

/**
 * @brief Gets a map from the mapset by name
 *
 * @param ms The map
 * @param map_name the map name used by the search
 * @return The next map
 */
struct map *
mapset_get_map_by_name(struct mapset *ms, char *map_name)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct mapset_handle*msh;
        struct map*curr_map;
        struct attr map_attr;
        if (!ms || !map_name)
        {
                return NULL;
        }
        msh = mapset_open(ms);
        while ((curr_map = mapset_next(msh, 1)))
        {
                //get map name
                if (map_get_attr(curr_map, attr_name, &map_attr, NULL))
                {
                        if (!strcmp(map_attr.u.str, map_name))
                        {
                                break;
                        }
                }
        }
        return curr_map;
}

/**
 * @brief Closes a mapset handle after it is no longer used
 *
 * @param msh Mapset handle to be closed
 */
void mapset_close(struct mapset_handle *msh)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        g_free(msh);
}

/**
 * @brief Holds information about a search in a mapset
 *
 * This struct holds information about a search (e.g. for a street) in a mapset. 
 *
 * @sa For a more detailed description see the documentation of mapset_search_new().
 */
struct mapset_search
{
        GList *map; /**< The list of maps to be searched within */
        struct map_search *ms; /**< A map search struct for the map currently active */
        struct item *item; /**< "Superior" item. */
        struct attr *search_attr; /**< Attribute to be searched for. */
        int partial; /**< Indicates if one would like to have partial matches */
};

/**
 * @brief Starts a search on a mapset
 *
 * This function starts a search on a mapset. What attributes one can search for depends on the
 * map plugin. See the description of map_search_new() in map.c for details.
 *
 * If you enable partial matches bear in mind that the search matches only the begin of the
 * strings - a search for a street named "street" would match to "streetfoo", but not to
 * "somestreet". Search is case insensitive.
 *
 * The item passed to this function specifies a "superior item" to "search within" - e.g. a town 
 * in which we want to search for a street, or a country in which to search for a town.
 *
 * @param ms The mapset that should be searched
 * @param item Specifies a superior item to "search within" (see description)
 * @param search_attr Attribute specifying what to search for. See description.
 * @param partial Set this to true to also have partial matches. See description.
 * @return A new mapset search struct for this search
 */
struct mapset_search *
mapset_search_new(struct mapset *ms, struct item *item, struct attr *search_attr, int partial)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct mapset_search *this;
        //dbg(0,"enter(%p,%p,%p,%d)\n", ms, item, search_attr, partial);
        this=g_new0(struct mapset_search,1);
        if (this != NULL && ms != NULL)
        {
                this->map = ms->maps;
                this->item = item;
                this->search_attr = search_attr;
                this->partial = partial;
                this->ms = map_search_new(this->map->data, item, search_attr, partial);
                return this;
        }
        else
        {
                return NULL;
        }
}

/**
 * @brief Returns the next found item from a mapset search
 *
 * This function returns the next item from a mapset search or NULL if there are no more items found.
 * It automatically iterates through all the maps in the mapset. Please note that maps which have the
 * attr_active attribute associated with them and set to false are not searched.
 *
 * @param this The mapset search to return an item from
 * @return The next found item or NULL if there are no more items found
 */
struct item *
mapset_search_get_item(struct mapset_search *this_)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        struct item *ret = NULL;
        struct attr active_attr;

        while ((this_) && (!this_->ms || !(ret = map_search_get_item(this_->ms))))
        { /* The current map has no more items to be returned */
                if (this_->search_attr->type >= attr_country_all && this_->search_attr->type <= attr_country_name)
                        break;
                for (;;)
                {
                        this_->map = g_list_next(this_->map);
                        if (!this_->map)
                                break;
                        if (map_get_attr(this_->map->data, attr_search_active, &active_attr, NULL))
                        {
                                if (!active_attr.u.num)
                                        continue;
                        }
                        if (!map_get_attr(this_->map->data, attr_active, &active_attr, NULL))
                                break;
                        if (active_attr.u.num)
                                break;
                }
                if (!this_->map)
                        break;
                map_search_destroy(this_->ms);
                this_->ms = map_search_new(this_->map->data, this_->item, this_->search_attr, this_->partial);
        }
        return ret;
}

/**
 * @brief Destroys a mapset search
 *
 * @param this The mapset search to be destroyed
 */
void mapset_search_destroy(struct mapset_search *this_)
{
#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
        dbg(0,"+#+:enter\n");
#endif
        if (this_)
        {
                map_search_destroy(this_->ms);
                g_free(this_);
        }
}
1	zoff99	2	/**
2	zoff99	31	* ZANavi, Zoff Android Navigation system.
3	zoff99	34	* Copyright (C) 2011-2013 Zoff <zoff@zoff.cc>
4	zoff99	31	*
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			/**
21	zoff99	2	* Navit, a modular navigation system.
22			* Copyright (C) 2005-2008 Navit Team
23			*
24			* This program is free software; you can redistribute it and/or
25			* modify it under the terms of the GNU General Public License
26			* version 2 as published by the Free Software Foundation.
27			*
28			* This program is distributed in the hope that it will be useful,
29			* but WITHOUT ANY WARRANTY; without even the implied warranty of
30			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31			* GNU General Public License for more details.
32			*
33			* You should have received a copy of the GNU General Public License
34			* along with this program; if not, write to the
35			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
36			* Boston, MA 02110-1301, USA.
37			*/
38
39			/** @file
40			*
41			* @brief Contains code used for loading more than one map
42			*
43			* The code in this file introduces "mapsets", which are collections of several maps.
44			* This enables navit to operate on more than one map at once. See map.c / map.h to learn
45			* how maps are handled.
46			*/
47
48			#include <string.h>
49			#include <glib.h>
50			#include <glib/gprintf.h>
51			#include "debug.h"
52			#include "item.h"
53			#include "mapset.h"
54			#include "projection.h"
55			#include "map.h"
56
57			/**
58			* @brief A mapset
59			*
60			* This structure holds a complete mapset
61			*/
62	zoff99	28	struct mapset
63			{
64	zoff99	2	GList maps; /< Linked list of all the maps in the mapset /
65			};
66
67	zoff99	28	struct attr_iter
68			{
69	zoff99	2	GList *last;
70			};
71
72			/**
73			* @brief Creates a new, empty mapset
74			*
75			* @return The new mapset
76			*/
77			struct mapset mapset_new(struct attr parent, struct attr **attrs)
78			{
79	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
80			dbg(0,"+#+:enter\n");
81			#endif
82	zoff99	2	struct mapset *ms;
83
84			ms=g_new0(struct mapset, 1);
85
86	zoff99	40	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
87			dbg(0,"+#+:leave\n");
88			#endif
89
90	zoff99	2	return ms;
91			}
92
93			struct attr_iter *
94			mapset_attr_iter_new(void)
95			{
96	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
97			dbg(0,"+#+:enter\n");
98			#endif
99			return g_new0(struct attr_iter, 1);
100	zoff99	2	}
101
102	zoff99	28	void mapset_attr_iter_destroy(struct attr_iter *iter)
103	zoff99	2	{
104	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
105			dbg(0,"+#+:enter\n");
106			#endif
107	zoff99	2	g_free(iter);
108			}
109
110			/**
111			* @brief Adds a map to a mapset
112			*
113			* @param ms The mapset to add the map to
114			* @param m The map to be added
115			*/
116	zoff99	28	int mapset_add_attr(struct mapset ms, struct attr attr)
117	zoff99	2	{
118	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
119			dbg(0,"+#+:enter\n");
120			#endif
121			switch (attr->type)
122			{
123			case attr_map:
124			ms->maps = g_list_append(ms->maps, attr->u.map);
125			map_ref(attr->u.map);
126			return 1;
127			default:
128			return 0;
129	zoff99	2	}
130			}
131
132	zoff99	28	int mapset_add_attr_name(struct mapset ms, struct attr attr)
133	zoff99	2	{
134	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
135			dbg(0,"+#+:enter\n");
136			#endif
137	zoff99	2	struct attr map_name;
138
139	zoff99	28	dbg(0, "**** ADD MAP from sdcard ****");
140			switch (attr->type)
141			{
142			case attr_map:
143			ms->maps = g_list_append(ms->maps, attr->u.map);
144			map_ref(attr->u.map);
145	zoff99	2
146	zoff99	28	struct map *m;
147			m=g_new0(struct map, 1);
148			m = attr->u.map;
149			struct attr *map_file_name = attr_search(m->attrs, NULL, attr_data);
150			map_name.type = attr_name;
151			map_name.u.str = g_strconcat("_ms_sdcard_map:", map_file_name->u.str, NULL);
152	zoff99	2
153	zoff99	28	dbg(0, "====== map name1=%s", map_name.u.str);
154			map_set_attr(attr->u.map, &map_name);
155	zoff99	2
156	zoff99	28	return 1;
157			default:
158			return 0;
159	zoff99	2	}
160			}
161
162	zoff99	28	int mapset_add_attr_name_str(struct mapset ms, struct attr attr, char *map_name_str)
163	zoff99	27	{
164	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
165			dbg(0,"+#+:enter\n");
166			#endif
167	zoff99	27	struct attr map_name;
168	zoff99	2
169	zoff99	28	dbg(0, "**** ADD MAP from sdcard - with name str ****");
170			switch (attr->type)
171			{
172			case attr_map:
173			ms->maps = g_list_append(ms->maps, attr->u.map);
174			map_ref(attr->u.map);
175	zoff99	27
176	zoff99	28	struct map *m;
177			m=g_new0(struct map, 1);
178			m = attr->u.map;
179			struct attr *map_file_name = attr_search(m->attrs, NULL, attr_data);
180			map_name.type = attr_name;
181			map_name.u.str = g_strconcat("_ms_sdcard_map:", map_name_str, NULL);
182	zoff99	27
183	zoff99	28	dbg(0, "====== map name2=%s", map_name.u.str);
184			map_set_attr(attr->u.map, &map_name);
185	zoff99	27
186	zoff99	28	return 1;
187			default:
188			return 0;
189	zoff99	27	}
190			}
191
192	zoff99	28	int mapset_remove_attr(struct mapset ms, struct attr attr)
193	zoff99	2	{
194	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
195			dbg(0,"+#+:enter\n");
196			#endif
197			switch (attr->type)
198			{
199			case attr_map:
200			ms->maps = g_list_remove(ms->maps, attr->u.map);
201			return 1;
202			default:
203			return 0;
204	zoff99	2	}
205			}
206
207	zoff99	28	int mapset_get_attr(struct mapset ms, enum attr_type type, struct attr attr, struct attr_iter *iter)
208	zoff99	2	{
209	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
210			dbg(0,"+#+:enter\n");
211			#endif
212	zoff99	2	GList *map;
213	zoff99	28	map = ms->maps;
214			attr->type = type;
215			switch (type)
216			{
217			case attr_map:
218			while (map)
219			{
220			if (!iter \|\| iter->last == g_list_previous(map))
221			{
222			attr->u.map = map->data;
223			if (iter)
224			iter->last = map;
225			return 1;
226			}
227			map = g_list_next(map);
228	zoff99	2	}
229	zoff99	28	break;
230			default:
231			break;
232	zoff99	2	}
233			return 0;
234			}
235
236			#if 0
237			static void mapset_maps_free(struct mapset *ms)
238			{
239			/* todo */
240			}
241			#endif
242
243			/**
244			* @brief Destroys a mapset.
245			*
246			* This destroys a mapset. Please note that it does not touch the contained maps
247			* in any way.
248			*
249			* @param ms The mapset to be destroyed
250			*/
251			void mapset_destroy(struct mapset *ms)
252			{
253	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
254			dbg(0,"+#+:enter\n");
255			#endif
256	zoff99	2	GList *map;
257	zoff99	28	map = ms->maps;
258	zoff99	34
259	zoff99	28	while (map)
260			{
261	zoff99	2	map_destroy(map->data);
262	zoff99	28	map = g_list_next(map);
263	zoff99	2	}
264			g_free(ms);
265			}
266
267			/**
268			* @brief Handle for a mapset in use
269			*
270			* This struct is used for a mapset that is in use. With this it is possible to iterate
271			* all maps in a mapset.
272			*/
273	zoff99	28	struct mapset_handle
274			{
275			GList l; /< Pointer to the current (next) map /
276	zoff99	2	};
277
278			/**
279			* @brief Returns a new handle for a mapset
280			*
281			* This returns a new handle for an existing mapset. The new handle points to the first
282			* map in the set.
283			*
284			* @param ms The mapset to get a handle of
285			* @return The new mapset handle
286			*/
287			struct mapset_handle *
288			mapset_open(struct mapset *ms)
289			{
290	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
291			dbg(0,"+#+:enter\n");
292			#endif
293			struct mapset_handle *ret = NULL;
294			if (ms)
295	zoff99	2	{
296			ret=g_new(struct mapset_handle, 1);
297	zoff99	28	ret->l = ms->maps;
298	zoff99	2	}
299
300			return ret;
301			}
302
303			/**
304			* @brief Gets the next map from a mapset handle
305			*
306			* If you set active to true, this function will not return any maps that
307			* have the attr_active attribute associated with them and set to false.
308			*
309			* @param msh The mapset handle to get the next map of
310			* @param active Set to true to only get active maps (See description)
311			* @return The next map
312			*/
313			struct map * mapset_next(struct mapset_handle *msh, int active)
314			{
315	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
316			dbg(0,"+#+:enter\n");
317			#endif
318	zoff99	2	struct map *ret;
319			struct attr active_attr;
320
321	zoff99	28	for (;;)
322			{
323	zoff99	2	if (!msh \|\| !msh->l)
324	zoff99	34	{
325	zoff99	2	return NULL;
326	zoff99	34	}
327
328	zoff99	28	ret = msh->l->data;
329			msh->l = g_list_next(msh->l);
330	zoff99	34
331	zoff99	2	if (!active)
332	zoff99	34	{
333	zoff99	28	return ret;
334	zoff99	34	}
335
336	zoff99	28	if (active == 2 && map_get_attr(ret, attr_route_active, &active_attr, NULL))
337			{
338	zoff99	2	if (active_attr.u.num)
339			return ret;
340			else
341			continue;
342			}
343	zoff99	34
344	zoff99	28	if (active == 3 && map_get_attr(ret, attr_search_active, &active_attr, NULL))
345			{
346	zoff99	2	if (active_attr.u.num)
347			return ret;
348			else
349			continue;
350			}
351	zoff99	34
352	zoff99	2	if (!map_get_attr(ret, attr_active, &active_attr, NULL))
353			return ret;
354	zoff99	34
355	zoff99	2	if (active_attr.u.num)
356			return ret;
357			}
358			}
359
360			/**
361			* @brief Gets a map from the mapset by name
362			*
363			* @param ms The map
364			* @param map_name the map name used by the search
365			* @return The next map
366			*/
367	zoff99	28	struct map *
368	zoff99	27	mapset_get_map_by_name(struct mapset ms, char map_name)
369	zoff99	2	{
370	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
371			dbg(0,"+#+:enter\n");
372			#endif
373	zoff99	2	struct mapset_handle*msh;
374			struct map*curr_map;
375			struct attr map_attr;
376	zoff99	28	if (!ms \|\| !map_name)
377			{
378	zoff99	2	return NULL;
379			}
380	zoff99	28	msh = mapset_open(ms);
381			while ((curr_map = mapset_next(msh, 1)))
382			{
383	zoff99	2	//get map name
384	zoff99	28	if (map_get_attr(curr_map, attr_name, &map_attr, NULL))
385			{
386			if (!strcmp(map_attr.u.str, map_name))
387			{
388	zoff99	2	break;
389			}
390			}
391			}
392			return curr_map;
393			}
394
395			/**
396			* @brief Closes a mapset handle after it is no longer used
397			*
398			* @param msh Mapset handle to be closed
399			*/
400	zoff99	28	void mapset_close(struct mapset_handle *msh)
401	zoff99	2	{
402	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
403			dbg(0,"+#+:enter\n");
404			#endif
405	zoff99	2	g_free(msh);
406			}
407
408			/**
409			* @brief Holds information about a search in a mapset
410			*
411			* This struct holds information about a search (e.g. for a street) in a mapset.
412			*
413			* @sa For a more detailed description see the documentation of mapset_search_new().
414			*/
415	zoff99	28	struct mapset_search
416			{
417			GList map; /< The list of maps to be searched within /
418			struct map_search ms; /< A map search struct for the map currently active /
419			struct item item; /< "Superior" item. /
420			struct attr search_attr; /< Attribute to be searched for. /
421			int partial; /*< Indicates if one would like to have partial matches /
422	zoff99	2	};
423
424			/**
425			* @brief Starts a search on a mapset
426			*
427			* This function starts a search on a mapset. What attributes one can search for depends on the
428			* map plugin. See the description of map_search_new() in map.c for details.
429			*
430			* If you enable partial matches bear in mind that the search matches only the begin of the
431			* strings - a search for a street named "street" would match to "streetfoo", but not to
432			* "somestreet". Search is case insensitive.
433			*
434			* The item passed to this function specifies a "superior item" to "search within" - e.g. a town
435			* in which we want to search for a street, or a country in which to search for a town.
436			*
437			* @param ms The mapset that should be searched
438			* @param item Specifies a superior item to "search within" (see description)
439			* @param search_attr Attribute specifying what to search for. See description.
440			* @param partial Set this to true to also have partial matches. See description.
441			* @return A new mapset search struct for this search
442			*/
443			struct mapset_search *
444			mapset_search_new(struct mapset ms, struct item item, struct attr *search_attr, int partial)
445			{
446	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
447			dbg(0,"+#+:enter\n");
448			#endif
449	zoff99	2	struct mapset_search *this;
450	zoff99	11	//dbg(0,"enter(%p,%p,%p,%d)\n", ms, item, search_attr, partial);
451	zoff99	2	this=g_new0(struct mapset_search,1);
452	zoff99	28	if (this != NULL && ms != NULL)
453			{
454			this->map = ms->maps;
455			this->item = item;
456			this->search_attr = search_attr;
457			this->partial = partial;
458			this->ms = map_search_new(this->map->data, item, search_attr, partial);
459	zoff99	2	return this;
460			}
461			else
462			{
463			return NULL;
464			}
465			}
466
467			/**
468			* @brief Returns the next found item from a mapset search
469			*
470			* This function returns the next item from a mapset search or NULL if there are no more items found.
471			* It automatically iterates through all the maps in the mapset. Please note that maps which have the
472			* attr_active attribute associated with them and set to false are not searched.
473			*
474			* @param this The mapset search to return an item from
475			* @return The next found item or NULL if there are no more items found
476			*/
477			struct item *
478			mapset_search_get_item(struct mapset_search *this_)
479			{
480	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
481			dbg(0,"+#+:enter\n");
482			#endif
483			struct item *ret = NULL;
484	zoff99	2	struct attr active_attr;
485
486	zoff99	28	while ((this_) && (!this_->ms \|\| !(ret = map_search_get_item(this_->ms))))
487			{ /* The current map has no more items to be returned */
488	zoff99	2	if (this_->search_attr->type >= attr_country_all && this_->search_attr->type <= attr_country_name)
489			break;
490	zoff99	28	for (;;)
491			{
492			this_->map = g_list_next(this_->map);
493			if (!this_->map)
494	zoff99	2	break;
495	zoff99	28	if (map_get_attr(this_->map->data, attr_search_active, &active_attr, NULL))
496			{
497	zoff99	2	if (!active_attr.u.num)
498			continue;
499			}
500			if (!map_get_attr(this_->map->data, attr_active, &active_attr, NULL))
501			break;
502			if (active_attr.u.num)
503			break;
504			}
505	zoff99	28	if (!this_->map)
506	zoff99	2	break;
507			map_search_destroy(this_->ms);
508	zoff99	28	this_->ms = map_search_new(this_->map->data, this_->item, this_->search_attr, this_->partial);
509	zoff99	2	}
510			return ret;
511			}
512
513			/**
514			* @brief Destroys a mapset search
515			*
516			* @param this The mapset search to be destroyed
517			*/
518	zoff99	28	void mapset_search_destroy(struct mapset_search *this_)
519	zoff99	2	{
520	zoff99	28	#ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
521			dbg(0,"+#+:enter\n");
522			#endif
523			if (this_)
524			{
525	zoff99	2	map_search_destroy(this_->ms);
526			g_free(this_);
527			}
528			}