You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
280 lines
6.9 KiB
280 lines
6.9 KiB
/***************************************************************************
|
|
* map_nodepois.c
|
|
*
|
|
* Copyright 2010 - Steffen Pohle
|
|
* steffen@gulpe.de
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
|
|
#include "map.h"
|
|
#include "memoryleak.h"
|
|
#include "system.h"
|
|
|
|
/*****************************************************
|
|
*
|
|
* Place information Handling
|
|
*
|
|
*/
|
|
|
|
|
|
/*
|
|
* copy data for the place, the next value will be untouched
|
|
*/
|
|
void map_place_copy (struct map_place *dest, struct map_place *src) {
|
|
int len = 5; // nullterminated chars inside
|
|
char *next = dest->data;
|
|
|
|
dest->country = next;
|
|
if (src->country) {
|
|
len += strlen (src->country);
|
|
strcpy (dest->country, src->country);
|
|
next = next + strlen (src->country);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->state = next;
|
|
if (src->state) {
|
|
len += strlen (src->state);
|
|
strcpy (dest->state, src->state);
|
|
next = next + strlen (src->state);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->district = next;
|
|
if (src->district) {
|
|
len += strlen (src->district);
|
|
strcpy (dest->district, src->district);
|
|
next = next + strlen (src->district);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->name = next;
|
|
if (src->name) {
|
|
len += strlen (src->name);
|
|
strcpy (dest->name, src->name);
|
|
next = next + strlen (src->name);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->postalcode = next;
|
|
if (src->postalcode) {
|
|
len += strlen (src->postalcode);
|
|
strcpy (dest->postalcode, src->postalcode);
|
|
next = next + strlen (src->postalcode);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->type = src->type;
|
|
dest->population = src->population;
|
|
dest->id = src->id;
|
|
dest->lon = src->lon;
|
|
dest->lat = src->lat;
|
|
};
|
|
|
|
|
|
int map_place_add (struct map_place *place, int loadflags) {
|
|
struct map_hash *mh;
|
|
int size;
|
|
|
|
size = map_place_getsize (place) + POINTERALIGNMENT;
|
|
mh = map_hash_get (place->lon, place->lat, loadflags);
|
|
if (mh == NULL) {
|
|
mh = map_hash_alloc (size + MAP_HASH_DEFAULTSIZE);
|
|
mh->pos.ilon = map_geo2igeo (place->lon);
|
|
mh->pos.ilat = map_geo2igeo (place->lat);
|
|
map_hash_add (mh);
|
|
}
|
|
else if (size >= map_hash_getfree_size (mh)) {
|
|
mh = map_hash_realloc (mh, mh->datasize + size + MAP_HASH_DEFAULTSIZE);
|
|
}
|
|
|
|
return map_place_add_to_hash (mh, place);
|
|
};
|
|
|
|
|
|
int map_place_add_to_hash (struct map_hash *mh, struct map_place *place) {
|
|
int size;
|
|
struct map_place *p;
|
|
|
|
/* check if the first element is already the one we want to update */
|
|
if (mh->places && mh->places->id == place->id) {
|
|
mh->places = mh->places->next;
|
|
mh->placescnt--;
|
|
}
|
|
|
|
/* find possible update and go to the end */
|
|
if (mh->places) {
|
|
/* find last place */
|
|
p = mh->places;
|
|
while (p && p->next) {
|
|
if (p->next->id == place->id || p->id == place->id) {
|
|
/* found old place.. just delete .. */
|
|
p->next = p->next->next;
|
|
mh->placescnt--;
|
|
}
|
|
if (p->next) p = p->next;
|
|
}
|
|
p->next = (struct map_place*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
p = p->next;
|
|
}
|
|
else {
|
|
/* complete new ways */
|
|
mh->places = (struct map_place*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
p = (struct map_place*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
}
|
|
|
|
/* copy the place data to the free entry
|
|
* calc size and set free entry to it's new place */
|
|
size = map_place_getsize (place);
|
|
map_place_copy (p, place);
|
|
p->next = NULL;
|
|
mh->free = ((void*)p) + size;
|
|
mh->placescnt++;
|
|
SETFLAG(mh->status, MS_changed);
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
int map_place_getsize (struct map_place *place) {
|
|
int size = 5 + sizeof (struct map_place);
|
|
|
|
if (place->country) size += strlen (place->country);
|
|
if (place->state) size += strlen (place->state);
|
|
if (place->district) size += strlen (place->district);
|
|
if (place->name) size += strlen (place->name);
|
|
if (place->postalcode) size += strlen (place->postalcode);
|
|
|
|
return size;
|
|
};
|
|
|
|
|
|
/*****************************************************
|
|
*
|
|
* POI information Handling
|
|
*
|
|
*/
|
|
void map_poi_copy (struct map_poi *dest, struct map_poi *src) {
|
|
int len = 2; // nullterminated chars inside
|
|
char *next = dest->data;
|
|
|
|
dest->name = next;
|
|
if (src->name) {
|
|
len += strlen (src->name);
|
|
strcpy (dest->name, src->name);
|
|
next = next + strlen (src->name);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->additional = next;
|
|
if (src->additional) {
|
|
len += strlen (src->additional);
|
|
strcpy (dest->additional, src->additional);
|
|
next = next + strlen (src->additional);
|
|
}
|
|
next[0] = 0;
|
|
next += 1;
|
|
|
|
dest->type = src->type;
|
|
dest->id = src->id;
|
|
dest->lon = src->lon;
|
|
dest->lat = src->lat;
|
|
};
|
|
|
|
|
|
int map_poi_add (struct map_poi *poi, int loadflags) {
|
|
struct map_hash *mh;
|
|
int size;
|
|
|
|
size = map_poi_getsize (poi) + POINTERALIGNMENT;
|
|
mh = map_hash_get (poi->lon, poi->lat, loadflags);
|
|
if (mh == NULL) {
|
|
mh = map_hash_alloc (size + MAP_HASH_DEFAULTSIZE);
|
|
mh->pos.ilon = map_geo2igeo (poi->lon);
|
|
mh->pos.ilat = map_geo2igeo (poi->lat);
|
|
map_hash_add (mh);
|
|
}
|
|
else if (size >= map_hash_getfree_size (mh)) {
|
|
mh = map_hash_realloc (mh, mh->datasize + size + MAP_HASH_DEFAULTSIZE);
|
|
}
|
|
|
|
return map_poi_add_to_hash (mh, poi);
|
|
};
|
|
|
|
|
|
int map_poi_add_to_hash (struct map_hash *mh, struct map_poi *poi) {
|
|
int size;
|
|
struct map_poi *p;
|
|
|
|
/* check if the first element is already the one we want to update */
|
|
if (mh->pois && mh->pois->id == poi->id) {
|
|
mh->pois = mh->pois->next;
|
|
mh->poiscnt--;
|
|
}
|
|
|
|
/* find possible update and go to the end */
|
|
if (mh->pois) {
|
|
/* find last place */
|
|
p = mh->pois;
|
|
while (p && p->next) {
|
|
if (p->next->id == poi->id || p->id == poi->id) {
|
|
/* found old place.. just delete .. */
|
|
p->next = p->next->next;
|
|
mh->poiscnt--;
|
|
}
|
|
if (p->next) p = p->next;
|
|
}
|
|
p->next = (struct map_poi*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
p = p->next;
|
|
}
|
|
else {
|
|
/* complete new ways */
|
|
mh->pois = (struct map_poi*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
p = (struct map_poi*) map_hash_getfree_aligned (mh, POINTERALIGNMENT);
|
|
}
|
|
|
|
/* copy the place data to the free entry
|
|
* calc size and set free entry to it's new place */
|
|
size = map_poi_getsize (poi);
|
|
map_poi_copy (p, poi);
|
|
p->next = NULL;
|
|
mh->free = ((void*)p) + size;
|
|
mh->poiscnt++;
|
|
SETFLAG(mh->status, MS_changed);
|
|
|
|
return 1;
|
|
};
|
|
|
|
|
|
int map_poi_getsize (struct map_poi *poi) {
|
|
int size = 2 + sizeof (struct map_poi);
|
|
|
|
if (poi->name) size += strlen (poi->name);
|
|
if (poi->additional) size += strlen (poi->additional);
|
|
|
|
return size;
|
|
};
|
|
|