git.maemo.org Git - navit-package/blob - navit/mapset.c

   1 /**
   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 /** @file
  21  *
  22  * @brief Contains code used for loading more than one map
  23  *
  24  * The code in this file introduces "mapsets", which are collections of several maps.
  25  * This enables navit to operate on more than one map at once. See map.c / map.h to learn
  26  * how maps are handled.
  27  */
  28
  29 #include <string.h>
  30 #include <glib.h>
  31 #include <glib/gprintf.h>
  32 #include "debug.h"
  33 #include "item.h"
  34 #include "mapset.h"
  35 #include "projection.h"
  36 #include "map.h"
  37
  38 /**
  39  * @brief A mapset
  40  *
  41  * This structure holds a complete mapset
  42  */
  43 struct mapset {
  44         GList *maps; /**< Linked list of all the maps in the mapset */
  45 };
  46
  47 struct attr_iter {
  48         GList *last;
  49 };
  50
  51 /**
  52  * @brief Creates a new, empty mapset
  53  *
  54  * @return The new mapset
  55  */
  56 struct mapset *mapset_new(struct attr *parent, struct attr **attrs)
  57 {
  58         struct mapset *ms;
  59
  60         ms=g_new0(struct mapset, 1);
  61
  62         return ms;
  63 }
  64
  65
  66 struct attr_iter *
  67 mapset_attr_iter_new(void)
  68 {
  69         return g_new0(struct attr_iter, 1);
  70 }
  71
  72 void
  73 mapset_attr_iter_destroy(struct attr_iter *iter)
  74 {
  75         g_free(iter);
  76 }
  77
  78 /**
  79  * @brief Adds a map to a mapset
  80  *
  81  * @param ms The mapset to add the map to
  82  * @param m The map to be added
  83  */
  84 int
  85 mapset_add_attr(struct mapset *ms, struct attr *attr)
  86 {
  87         switch (attr->type) {
  88         case attr_map:
  89                 ms->maps=g_list_append(ms->maps, attr->u.map);
  90                 return 1;
  91         default:
  92                 return 0;
  93         }
  94 }
  95
  96 int
  97 mapset_get_attr(struct mapset *ms, enum attr_type type, struct attr *attr, struct attr_iter *iter)
  98 {
  99         GList *map;
 100         map=ms->maps;
 101         attr->type=type;
 102         switch (type) {
 103         case attr_map:
 104                 while (map) {
 105                         if (!iter || iter->last == g_list_previous(map)) {
 106                                 attr->u.map=map->data;
 107                                 if (iter)
 108                                         iter->last=map;
 109                                 return 1;
 110                         }
 111                         map=g_list_next(map);
 112                 }
 113                 break;
 114         default:
 115                 break;
 116         }
 117         return 0;
 118 }
 119
 120
 121 #if 0
 122 static void mapset_maps_free(struct mapset *ms)
 123 {
 124         /* todo */
 125 }
 126 #endif
 127
 128 /**
 129  * @brief Destroys a mapset.
 130  *
 131  * This destroys a mapset. Please note that it does not touch the contained maps
 132  * in any way.
 133  *
 134  * @param ms The mapset to be destroyed
 135  */
 136 void mapset_destroy(struct mapset *ms)
 137 {
 138         g_free(ms);
 139 }
 140
 141 /**
 142  * @brief Handle for a mapset in use
 143  *
 144  * This struct is used for a mapset that is in use. With this it is possible to iterate
 145  * all maps in a mapset.
 146  */
 147 struct mapset_handle {
 148         GList *l;       /**< Pointer to the current (next) map */
 149 };
 150
 151 /**
 152  * @brief Returns a new handle for a mapset
 153  *
 154  * This returns a new handle for an existing mapset. The new handle points to the first
 155  * map in the set.
 156  *
 157  * @param ms The mapset to get a handle of
 158  * @return The new mapset handle
 159  */
 160 struct mapset_handle *
 161 mapset_open(struct mapset *ms)
 162 {
 163         struct mapset_handle *ret=NULL;
 164         if(ms)
 165         {
 166                 ret=g_new(struct mapset_handle, 1);
 167                 ret->l=ms->maps;
 168         }
 169
 170         return ret;
 171 }
 172
 173 /**
 174  * @brief Gets the next map from a mapset handle
 175  *
 176  * If you set active to true, this function will not return any maps that
 177  * have the attr_active attribute associated with them and set to false.
 178  *
 179  * @param msh The mapset handle to get the next map of
 180  * @param active Set to true to only get active maps (See description)
 181  * @return The next map
 182  */
 183 struct map * mapset_next(struct mapset_handle *msh, int active)
 184 {
 185         struct map *ret;
 186         struct attr active_attr;
 187
 188         for (;;) {
 189                 if (!msh || !msh->l)
 190                         return NULL;
 191                 ret=msh->l->data;
 192                 msh->l=g_list_next(msh->l);
 193                 if (!active)
 194                         return ret;
 195                 if (active == 2 && map_get_attr(ret, attr_route_active, &active_attr, NULL)) {
 196                         if (active_attr.u.num)
 197                                 return ret;
 198                         else
 199                                 continue;
 200                 }
 201                 if (!map_get_attr(ret, attr_active, &active_attr, NULL))
 202                         return ret;
 203                 if (active_attr.u.num)
 204                         return ret;
 205         }
 206 }
 207
 208 /**
 209  * @brief Closes a mapset handle after it is no longer used
 210  *
 211  * @param msh Mapset handle to be closed
 212  */
 213 void
 214 mapset_close(struct mapset_handle *msh)
 215 {
 216         g_free(msh);
 217 }
 218
 219 /**
 220  * @brief Holds information about a search in a mapset
 221  *
 222  * This struct holds information about a search (e.g. for a street) in a mapset.
 223  *
 224  * @sa For a more detailed description see the documentation of mapset_search_new().
 225  */
 226 struct mapset_search {
 227         GList *map;                                     /**< The list of maps to be searched within */
 228         struct map_search *ms;          /**< A map search struct for the map currently active */
 229         struct item *item;                      /**< "Superior" item. */
 230         struct attr *search_attr;       /**< Attribute to be searched for. */
 231         int partial;                            /**< Indicates if one would like to have partial matches */
 232 };
 233
 234 /**
 235  * @brief Starts a search on a mapset
 236  *
 237  * This function starts a search on a mapset. What attributes one can search for depends on the
 238  * map plugin. See the description of map_search_new() in map.c for details.
 239  *
 240  * If you enable partial matches bear in mind that the search matches only the begin of the
 241  * strings - a search for a street named "street" would match to "streetfoo", but not to
 242  * "somestreet". Search is case insensitive.
 243  *
 244  * The item passed to this function specifies a "superior item" to "search within" - e.g. a town
 245  * in which we want to search for a street, or a country in which to search for a town.
 246  *
 247  * @param ms The mapset that should be searched
 248  * @param item Specifies a superior item to "search within" (see description)
 249  * @param search_attr Attribute specifying what to search for. See description.
 250  * @param partial Set this to true to also have partial matches. See description.
 251  * @return A new mapset search struct for this search
 252  */
 253 struct mapset_search *
 254 mapset_search_new(struct mapset *ms, struct item *item, struct attr *search_attr, int partial)
 255 {
 256         struct mapset_search *this;
 257         dbg(1,"enter(%p,%p,%p,%d)\n", ms, item, search_attr, partial);
 258         this=g_new0(struct mapset_search,1);
 259         if(this != NULL && ms!=NULL )
 260         {
 261                 this->map=ms->maps;
 262                 this->item=item;
 263                 this->search_attr=search_attr;
 264                 this->partial=partial;
 265                 this->ms=map_search_new(this->map->data, item, search_attr, partial);
 266                 return this;
 267         }
 268         else
 269         {
 270                 return NULL;
 271         }
 272 }
 273
 274 /**
 275  * @brief Returns the next found item from a mapset search
 276  *
 277  * This function returns the next item from a mapset search or NULL if there are no more items found.
 278  * It automatically iterates through all the maps in the mapset. Please note that maps which have the
 279  * attr_active attribute associated with them and set to false are not searched.
 280  *
 281  * @param this The mapset search to return an item from
 282  * @return The next found item or NULL if there are no more items found
 283  */
 284 struct item *
 285 mapset_search_get_item(struct mapset_search *this)
 286 {
 287         struct item *ret=NULL;
 288         struct attr active_attr;
 289
 290         while ((this) && (!this->ms || !(ret=map_search_get_item(this->ms)))) { /* The current map has no more items to be returned */
 291                 if (this->search_attr->type >= attr_country_all && this->search_attr->type <= attr_country_name)
 292                         break;
 293                 for (;;) {
 294                         this->map=g_list_next(this->map);
 295                         if (! this->map)
 296                                 break;
 297                         if (!map_get_attr(this->map->data, attr_active, &active_attr, NULL))
 298                                 break;
 299                         if (active_attr.u.num)
 300                                 break;
 301                 }
 302                 if (! this->map)
 303                         break;
 304                 map_search_destroy(this->ms);
 305                 this->ms=map_search_new(this->map->data, this->item, this->search_attr, this->partial);
 306         }
 307         return ret;
 308 }
 309
 310 /**
 311  * @brief Destroys a mapset search
 312  *
 313  * @param this The mapset search to be destroyed
 314  */
 315 void
 316 mapset_search_destroy(struct mapset_search *this)
 317 {
 318         if (this) {
 319                 map_search_destroy(this->ms);
 320                 g_free(this);
 321         }
 322 }