2013-06-11 12:33:10 +04:00
|
|
|
package diff
|
|
|
|
|
|
|
|
import (
|
2013-08-29 17:44:15 +04:00
|
|
|
"imposm3/cache"
|
|
|
|
"imposm3/database"
|
|
|
|
"imposm3/diff/parser"
|
|
|
|
"imposm3/element"
|
|
|
|
"imposm3/expire"
|
|
|
|
"imposm3/mapping"
|
|
|
|
"imposm3/proj"
|
2013-06-11 12:33:10 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
type Deleter struct {
|
2013-10-29 20:30:30 +04:00
|
|
|
delDb database.Deleter
|
|
|
|
osmCache *cache.OSMCache
|
|
|
|
diffCache *cache.DiffCache
|
|
|
|
tmPoints *mapping.TagMatcher
|
|
|
|
tmLineStrings *mapping.TagMatcher
|
|
|
|
tmPolygons *mapping.TagMatcher
|
2013-11-08 19:03:58 +04:00
|
|
|
expireor expire.Expireor
|
2013-10-29 20:30:30 +04:00
|
|
|
deletedRelations map[int64]struct{}
|
|
|
|
deletedWays map[int64]struct{}
|
2013-11-05 14:34:03 +04:00
|
|
|
deletedMembers map[int64]struct{}
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewDeleter(db database.Deleter, osmCache *cache.OSMCache, diffCache *cache.DiffCache,
|
|
|
|
tmPoints *mapping.TagMatcher,
|
|
|
|
tmLineStrings *mapping.TagMatcher,
|
|
|
|
tmPolygons *mapping.TagMatcher,
|
|
|
|
) *Deleter {
|
|
|
|
return &Deleter{
|
|
|
|
db,
|
|
|
|
osmCache,
|
|
|
|
diffCache,
|
|
|
|
tmPoints,
|
|
|
|
tmLineStrings,
|
|
|
|
tmPolygons,
|
2013-07-12 18:41:52 +04:00
|
|
|
nil,
|
2013-10-29 20:30:30 +04:00
|
|
|
make(map[int64]struct{}),
|
|
|
|
make(map[int64]struct{}),
|
2013-11-05 14:34:03 +04:00
|
|
|
make(map[int64]struct{}),
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-08 19:03:58 +04:00
|
|
|
func (d *Deleter) SetExpireor(exp expire.Expireor) {
|
|
|
|
d.expireor = exp
|
2013-07-12 18:41:52 +04:00
|
|
|
}
|
|
|
|
|
2013-11-05 14:34:03 +04:00
|
|
|
func (d *Deleter) DeletedMemberWays() map[int64]struct{} {
|
|
|
|
return d.deletedMembers
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Deleter) deleteRelation(id int64, deleteRefs bool, deleteMembers bool) {
|
2013-10-29 20:30:30 +04:00
|
|
|
d.deletedRelations[id] = struct{}{}
|
|
|
|
|
2013-06-11 12:33:10 +04:00
|
|
|
elem, err := d.osmCache.Relations.GetRelation(id)
|
|
|
|
if err != nil {
|
2013-06-21 17:09:57 +04:00
|
|
|
if err == cache.NotFound {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// TODO
|
2013-07-16 16:03:42 +04:00
|
|
|
log.Print("rel", id, err)
|
2013-06-21 17:09:57 +04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if elem.Tags == nil {
|
2013-06-11 12:33:10 +04:00
|
|
|
return
|
|
|
|
}
|
2013-10-28 15:01:57 +04:00
|
|
|
if ok, matches := d.delDb.ProbePolygon(elem.OSMElem); ok {
|
2013-11-07 19:09:08 +04:00
|
|
|
d.delDb.Delete(-elem.Id, matches)
|
2013-11-05 18:03:32 +04:00
|
|
|
} else {
|
|
|
|
// handle relations with tags from members by deleting
|
|
|
|
// from all tables
|
2013-11-07 19:09:08 +04:00
|
|
|
e := element.OSMElem(elem.OSMElem)
|
|
|
|
e.Id = -e.Id
|
|
|
|
d.delDb.DeleteElem(e)
|
2013-07-12 18:41:52 +04:00
|
|
|
}
|
2013-08-07 15:09:34 +04:00
|
|
|
|
2013-11-05 18:03:32 +04:00
|
|
|
if deleteRefs {
|
2013-08-07 15:09:34 +04:00
|
|
|
for _, m := range elem.Members {
|
|
|
|
if m.Type == element.WAY {
|
|
|
|
d.diffCache.Ways.DeleteRef(m.Id, id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-05 14:34:03 +04:00
|
|
|
if deleteMembers {
|
|
|
|
// delete members from db and force reinsert of members
|
|
|
|
// use case: relation is deleted and member now stands for its own
|
|
|
|
for _, member := range elem.Members {
|
|
|
|
if member.Type == element.WAY {
|
|
|
|
d.deletedMembers[member.Id] = struct{}{}
|
|
|
|
if _, ok := d.deletedWays[member.Id]; ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
d.deleteWay(member.Id, false)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-01 16:07:06 +04:00
|
|
|
d.osmCache.InsertedWays.DeleteMembers(elem.Members)
|
2013-11-08 19:03:58 +04:00
|
|
|
if d.expireor != nil {
|
2013-07-12 18:41:52 +04:00
|
|
|
for _, m := range elem.Members {
|
|
|
|
if m.Way == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
err := d.osmCache.Coords.FillWay(m.Way)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
proj.NodesToMerc(m.Way.Nodes)
|
2013-11-08 19:03:58 +04:00
|
|
|
expire.ExpireNodes(d.expireor, m.Way.Nodes)
|
2013-07-12 18:41:52 +04:00
|
|
|
}
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-07 15:09:34 +04:00
|
|
|
func (d *Deleter) deleteWay(id int64, deleteRefs bool) {
|
2013-10-29 20:30:30 +04:00
|
|
|
d.deletedWays[id] = struct{}{}
|
|
|
|
|
2013-06-11 12:33:10 +04:00
|
|
|
elem, err := d.osmCache.Ways.GetWay(id)
|
|
|
|
if err != nil {
|
2013-06-21 17:09:57 +04:00
|
|
|
if err == cache.NotFound {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// TODO
|
2013-07-16 16:03:42 +04:00
|
|
|
log.Print("way", id, err)
|
2013-06-21 17:09:57 +04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if elem.Tags == nil {
|
2013-06-11 12:33:10 +04:00
|
|
|
return
|
|
|
|
}
|
2013-07-12 18:41:52 +04:00
|
|
|
deleted := false
|
2013-10-28 15:01:57 +04:00
|
|
|
if ok, matches := d.delDb.ProbePolygon(elem.OSMElem); ok {
|
|
|
|
d.delDb.Delete(elem.Id, matches)
|
2013-07-12 18:41:52 +04:00
|
|
|
deleted = true
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
2013-10-28 15:01:57 +04:00
|
|
|
if ok, matches := d.delDb.ProbeLineString(elem.OSMElem); ok {
|
|
|
|
d.delDb.Delete(elem.Id, matches)
|
2013-07-12 18:41:52 +04:00
|
|
|
deleted = true
|
|
|
|
}
|
2013-08-07 15:09:34 +04:00
|
|
|
if deleted && deleteRefs {
|
2013-08-05 14:05:15 +04:00
|
|
|
for _, n := range elem.Refs {
|
|
|
|
d.diffCache.Coords.DeleteRef(n, id)
|
|
|
|
}
|
|
|
|
}
|
2013-11-08 19:03:58 +04:00
|
|
|
if deleted && d.expireor != nil {
|
2013-07-12 18:41:52 +04:00
|
|
|
err := d.osmCache.Coords.FillWay(elem)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
2013-11-08 19:03:58 +04:00
|
|
|
expire.ExpireNodes(d.expireor, elem.Nodes)
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Deleter) deleteNode(id int64) {
|
|
|
|
elem, err := d.osmCache.Nodes.GetNode(id)
|
|
|
|
if err != nil {
|
2013-06-21 17:09:57 +04:00
|
|
|
if err == cache.NotFound {
|
|
|
|
return
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
2013-06-21 17:09:57 +04:00
|
|
|
// TODO
|
2013-07-16 16:03:42 +04:00
|
|
|
log.Print("node", id, err)
|
2013-06-21 17:09:57 +04:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if elem.Tags == nil {
|
2013-06-11 12:33:10 +04:00
|
|
|
return
|
|
|
|
}
|
2013-07-12 18:41:52 +04:00
|
|
|
deleted := false
|
|
|
|
|
2013-10-28 15:01:57 +04:00
|
|
|
if ok, matches := d.delDb.ProbePoint(elem.OSMElem); ok {
|
|
|
|
d.delDb.Delete(elem.Id, matches)
|
2013-07-12 18:41:52 +04:00
|
|
|
deleted = true
|
|
|
|
}
|
2013-08-07 15:09:34 +04:00
|
|
|
|
2013-11-08 19:03:58 +04:00
|
|
|
if deleted && d.expireor != nil {
|
|
|
|
d.expireor.Expire(elem.Long, elem.Lat)
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
2013-07-12 18:41:52 +04:00
|
|
|
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Deleter) Delete(delElem parser.DiffElem) {
|
|
|
|
if !delElem.Del {
|
|
|
|
panic("del=false")
|
|
|
|
}
|
|
|
|
|
|
|
|
if delElem.Rel != nil {
|
2013-11-05 14:34:03 +04:00
|
|
|
d.deleteRelation(delElem.Rel.Id, true, true)
|
2013-06-11 12:33:10 +04:00
|
|
|
} else if delElem.Way != nil {
|
2013-08-07 15:09:34 +04:00
|
|
|
d.deleteWay(delElem.Way.Id, true)
|
2013-06-11 12:33:10 +04:00
|
|
|
|
|
|
|
if delElem.Mod {
|
|
|
|
dependers := d.diffCache.Ways.Get(delElem.Way.Id)
|
|
|
|
for _, rel := range dependers {
|
2013-10-29 20:30:30 +04:00
|
|
|
if _, ok := d.deletedRelations[rel]; ok {
|
|
|
|
continue
|
|
|
|
}
|
2013-11-05 14:34:03 +04:00
|
|
|
d.deleteRelation(rel, false, false)
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if delElem.Node != nil {
|
|
|
|
d.deleteNode(delElem.Node.Id)
|
|
|
|
if delElem.Mod {
|
|
|
|
dependers := d.diffCache.Coords.Get(delElem.Node.Id)
|
|
|
|
for _, way := range dependers {
|
2013-10-29 20:30:30 +04:00
|
|
|
if _, ok := d.deletedWays[way]; ok {
|
|
|
|
continue
|
|
|
|
}
|
2013-08-07 15:09:34 +04:00
|
|
|
d.deleteWay(way, false)
|
2013-06-11 12:33:10 +04:00
|
|
|
dependers := d.diffCache.Ways.Get(way)
|
2013-11-05 18:03:32 +04:00
|
|
|
if len(dependers) >= 1 {
|
|
|
|
// mark member ways from deleted relations for re-insert
|
|
|
|
d.deletedMembers[way] = struct{}{}
|
|
|
|
}
|
2013-06-11 12:33:10 +04:00
|
|
|
for _, rel := range dependers {
|
2013-10-29 20:30:30 +04:00
|
|
|
if _, ok := d.deletedRelations[rel]; ok {
|
|
|
|
continue
|
|
|
|
}
|
2013-11-05 14:34:03 +04:00
|
|
|
d.deleteRelation(rel, false, false)
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-08-07 15:09:34 +04:00
|
|
|
if !delElem.Add {
|
|
|
|
d.diffCache.Coords.Delete(delElem.Node.Id)
|
|
|
|
}
|
2013-06-11 12:33:10 +04:00
|
|
|
}
|
|
|
|
}
|