net/systemeD/halcyon/connection/Entity.as

   1 package net.systemeD.halcyon.connection {
   2
   3     import flash.events.Event;
   4     import flash.events.EventDispatcher;
   5     import flash.utils.Dictionary;
   6
   7     import net.systemeD.halcyon.connection.actions.*;
   8
   9     /** An Entity is an object stored in the map database, and therefore uploaded and downloaded. This includes Nodes, Ways,
  10     *   Relations but also Changesets etc. */
  11     public class Entity extends EventDispatcher {
  12                 private var _connection:Connection;
  13         private var _id:Number;
  14         private var _version:uint;
  15         private var _uid:Number;
  16         private var _timestamp:String;
  17         private var tags:Object = {};
  18         private var modified:Boolean = false;
  19         private var _loaded:Boolean = true;
  20         private var parents:Dictionary = new Dictionary();
  21                 public var status:String;
  22         /** Lock against purging when off-screen */
  23         public var locked:Boolean = false;
  24         public var deleted:Boolean = false;
  25         /** Have all its parents (ie, relations that contain this object as a member, ways that contain this node) been loaded into memory */
  26         public var parentsLoaded:Boolean = true;
  27
  28         public function Entity(connection:Connection, id:Number, version:uint, tags:Object, loaded:Boolean, uid:Number, timestamp:String) {
  29                         this._connection = connection;
  30             this._id = id;
  31             this._version = version;
  32             this._uid = uid;
  33             this._timestamp = timestamp;
  34             this.tags = tags;
  35                         this._loaded = loaded;
  36             modified = id < 0;
  37         }
  38
  39         /** OSM ID. */
  40         public function get id():Number {
  41             return _id;
  42         }
  43
  44         /** Current version number. */
  45         public function get version():uint {
  46             return _version;
  47         }
  48
  49         /** User ID who last edited this entity (from OSM API). */
  50         public function get uid():Number {
  51             return _uid;
  52         }
  53
  54                 /** Is entity fully loaded, or is it just a placeholder reference (as a relation member)? */
  55         public function get loaded():Boolean {
  56             return _loaded;
  57         }
  58
  59                 /** List of entities. Overridden by EntityCollection. */
  60                 public function get entities():Array {
  61                         return [this];
  62                 }
  63
  64         /** Most recent modification of the entity (from OSM API). */
  65         public function get timestamp():String {
  66             return _timestamp;
  67         }
  68
  69                 /** Connection to which this entity belongs. */
  70                 public function get connection():Connection {
  71                         return _connection;
  72                 }
  73
  74         /** Set a bunch of properties in one hit. Implicitly makes entity not deleted. */
  75         public function updateEntityProperties(version:uint, tags:Object, loaded:Boolean, parentsLoaded:Boolean, uid:Number, timestamp:String):void {
  76             _version=version; this.tags=tags; _loaded=loaded; this.parentsLoaded=parentsLoaded; _uid = uid; _timestamp = timestamp;
  77             deleted=false;
  78         }
  79
  80         /** Assign a new ID and version. */
  81         public function renumber(newID:Number, newVersion:uint):void {
  82             this._id = newID;
  83             this._version = newVersion;
  84         }
  85
  86                 // Tag-handling methods
  87
  88         /** Whether the entity has > 0 tags. */
  89         public function hasTags():Boolean {
  90             for (var key:String in tags)
  91                 return true;
  92             return false;
  93         }
  94
  95         /** Whether the entity has any tags other than meta-tags (attribution, created_by, source, tiger:...) */
  96         public function hasInterestingTags():Boolean {
  97             for (var key:String in tags) {
  98               if (key != "attribution" && key != "created_by" && key != "source" && key.indexOf('tiger:') != 0) {
  99                 //trace(key);
 100                 return true;
 101               }
 102             }
 103             return false;
 104         }
 105
 106                 /** Compare tags between two entities. */
 107                 public function sameTags(entity:Entity):Boolean {
 108                         var o:Object=entity.getTagsHash();
 109                         for (var k:String in tags)
 110                                 if (!o[k] || o[k]!=tags[k]) return false;
 111                         for (k in o)
 112                                 if (!tags[k] || tags[k]!=o[k]) return false;
 113                         return true;
 114                 }
 115
 116         /** Rough function to detect entities untouched since TIGER import. */
 117         public function isUneditedTiger():Boolean {
 118             // todo: make this match the rules from the tiger edited map
 119             // http://github.com/MapQuest/TIGER-Edited-map/blob/master/inc/layer-tiger.xml.inc
 120             if (this is Way && (uid == 7168 || uid == 15169 || uid == 20587)) {//todo fixme etc
 121               return true;
 122             }
 123             return false;
 124         }
 125
 126         /** Retrieve a tag by key. */
 127         public function getTag(key:String):String {
 128             return tags[key];
 129         }
 130
 131         /** @return true if there exists key=value */
 132         public function tagIs(key:String,value:String):Boolean {
 133             if (!tags[key]) { return false; }
 134             return tags[key]==value;
 135         }
 136
 137         /** Set key=value, with optional undoability.
 138          * @param key Name of key to set
 139          * @param value Value to set tag to
 140          * @param performAction Single-argument function to pass a SetTagAction to.
 141          * @example setTag("highway", "residential", MainUndoStack.getGlobalStack().addAction);
 142          */
 143         public function setTag(key:String, value:String, performAction:Function):void {
 144             performAction(new SetTagAction(this, key, value));
 145         }
 146
 147         /** Change oldKey=[value] to newKey=[value], with optional undoability.
 148          * @param oldKey Name of key to rename
 149          * @parame newKey New name of key
 150          * @param performAction Single-argument function to pass a SetTagKeyAction to.
 151          * @example renameTag("building", "amenity", MainUndoStack.getGlobalStack().addAction);
 152          */
 153         public function renameTag(oldKey:String, newKey:String, performAction:Function):void {
 154             performAction(new SetTagKeyAction(this, oldKey, newKey));
 155         }
 156
 157         public function getTagList():TagList {
 158             return new TagList(tags);
 159         }
 160
 161         /** Returns an object that duplicates the tags on this entity. */
 162         public function getTagsCopy():Object {
 163             var copy:Object = {};
 164             for (var key:String in tags )
 165                 copy[key] = tags[key];
 166             return copy;
 167         }
 168
 169         public function getTagsHash():Object {
 170             // hm, not sure we should be doing this, but for read-only purposes
 171             // it's faster than using getTagsCopy
 172             return tags;
 173         }
 174
 175         /** Returns an array that duplicates the tags on this entity. */
 176         public function getTagArray():Array {
 177             var copy:Array = [];
 178             for (var key:String in tags )
 179                 copy.push(new Tag(this, key, tags[key]));
 180             return copy;
 181         }
 182
 183                 /** Change entity status. */
 184                 public function setStatus(s:String):void {
 185                         if (s=='') s=null;
 186                         if (s==status) return;
 187                         status=s;
 188                         dispatchEvent(new EntityEvent(Connection.STATUS_CHANGED,this));
 189                 }
 190
 191                 // Clean/dirty methods
 192
 193         /** Check if entity is modified since last markClean(). */
 194         public function get isDirty():Boolean {
 195             return modified;
 196         }
 197
 198         /** Reset modified flag. You should not be calling this directly, instead you should be calling markClean from your UndoableEntityAction */
 199         public function markClean():void {
 200             modified = false;
 201         }
 202
 203         /** Set entity as modified. You should not be calling this directly, instead you should be calling markDirty from your UndoableEntityAction */
 204         internal function markDirty():void {
 205             modified = true;
 206         }
 207
 208
 209         /** Delete entity - must be overridden. */
 210         public function remove(performAction:Function):void {
 211             // to be overridden
 212         }
 213
 214         /** Whether entity is marked deleted. */
 215         public function isDeleted():Boolean {
 216             return deleted;
 217         }
 218
 219         /** Mark entity as deleted. */
 220         public function setDeletedState(isDeleted:Boolean):void {
 221             deleted = isDeleted;
 222             if (this is Node) {
 223                 var n:Node = Node(this);
 224                 if (isDeleted) {
 225                     connection.removeDupe(n);
 226                 } else {
 227                     connection.addDupe(n);
 228                 }
 229             }
 230         }
 231
 232         /** Whether entity is "empty" - to be overridden by subclass. */
 233         internal function isEmpty():Boolean {
 234             return false;
 235         }
 236
 237         /** Free up memory by converting entity to a dummy entity, for entities that we no longer need
 238         *  but which are part of a still-in-memory relation */
 239         public function nullify():void {
 240             nullifyEntity();
 241         }
 242
 243         /** Implement nullifybehaviour: delete tags, etc. */
 244         protected function nullifyEntity():void {
 245             // this is the common nullify behaviour for all entity types (we'd call this by super() if ActionScript let us)
 246             _version=0;
 247             _loaded=false;
 248             tags={};
 249         }
 250
 251
 252         public function within(left:Number,right:Number,top:Number,bottom:Number):Boolean {
 253             return true;        // to be overridden
 254         }
 255
 256         public function removeFromParents(performAction:Function):void {
 257             for (var o:Object in parents) {
 258                 if (o is Relation) { Relation(o).removeMember(this, performAction); }
 259                 else if (o is Way) { Way(o).removeNode(Node(this), performAction); }
 260                 if (o.isEmpty()) { o.remove(performAction); }
 261             }
 262         }
 263
 264         // Parent handling
 265
 266         /** Create parent link from this entity to another. */
 267         public function addParent(parent:Entity):void {
 268             parents[parent]=true;
 269
 270             if ( parent is Relation )
 271                 dispatchEvent(new RelationMemberEvent(Connection.ADDED_TO_RELATION, this, parent as Relation, -1));
 272         }
 273
 274         /** Remove parent link. */
 275         public function removeParent(parent:Entity):void {
 276             delete parents[parent];
 277
 278             if ( parent is Relation )
 279                 dispatchEvent(new RelationMemberEvent(Connection.REMOVED_FROM_RELATION, this, parent as Relation, -1));
 280         }
 281
 282         /** Get array of all Ways of which this object (presumably a node) is a child. */
 283         public function get parentWays():Array {
 284             var a:Array=[];
 285             for (var o:Object in parents) {
 286                 if (o is Way) { a.push(o); }
 287             }
 288             return a;
 289         }
 290
 291         /** Whether this entity has any parents. */
 292         public function get hasParents():Boolean {
 293             for (var o:Object in parents) { return true; }
 294             return false;
 295         }
 296
 297         /** Whether this entity has any parents that are Ways. */
 298         public function get hasParentWays():Boolean {
 299             for (var o:Object in parents) {
 300                 if (o is Way) { return true; }
 301             }
 302             return false;
 303         }
 304
 305         /** How many parents are Ways? */
 306         public function get numParentWays():uint {
 307             var i:uint=0;
 308             for (var o:Object in parents) {
 309                 if (o is Way) { i++; }
 310             }
 311             return i;
 312         }
 313
 314         /** All parents that are Relations */
 315         public function get parentRelations():Array {
 316             var a:Array=[];
 317             for (var o:Object in parents) {
 318                 if (o is Relation) { a.push(o); }
 319             }
 320             return a;
 321         }
 322
 323         /** Returns parents that are relations, and of the specified type, and of which this entity is the correct role (if provided).
 324         *
 325         * @example entity.findParentRelationsOfType('multipolygon','inner');
 326         */
 327         public function findParentRelationsOfType(type:String, role:String=null):Array {
 328             var a:Array=[];
 329             for (var o:Object in parents) {
 330                 if (o is Relation && Relation(o).tagIs('type',type) && (role==null || Relation(o).hasMemberInRole(this,role))) {
 331                     a.push(o);
 332                 }
 333             }
 334             return a;
 335         }
 336
 337                 public function getRelationMemberships():Array {
 338                         var memberships:Array = [];
 339                         for each( var rel:Relation in parentRelations ) {
 340                                 for each( var memberIndex:int in rel.findEntityMemberIndexes(this)) {
 341                                         memberships.push({
 342                                                 relation: rel,
 343                                                 id: rel.id,
 344                                                 index: memberIndex,
 345                                                 role: rel.getMember(memberIndex).role,
 346                                                 description: rel.getDescription(),
 347                                                 id_idx: rel.id + "/"+memberIndex });
 348                                 }
 349                         }
 350                         return memberships;
 351                 }
 352
 353         /** How many parents does this entity have that satisfy the "within" constraint? */
 354         public function countParentObjects(within:Object):uint {
 355             var count:uint=0;
 356             for (var o:Object in parents) {
 357                 if (o.getType()==within.entity && o.getTag(within.k)) {
 358                     if (within.v && within.v!=o.getTag(within.k)) { break; }
 359                     if (within.role && !Relation(o).hasMemberInRole(this,within.role)) { break; }
 360                     count++;
 361                 }
 362             }
 363             return count;
 364         }
 365
 366         /** All parents of this entity. */
 367         public function get parentObjects():Array {
 368             var a:Array=[];
 369             for (var o:Object in parents) { a.push(o); }
 370                 return a;
 371             }
 372
 373         /** Whether 'entity' is a parent of this Entity. */
 374         public function hasParent(entity:Entity):Boolean {
 375             return parents[entity] == true;
 376         }
 377
 378             /** Returns all relations that this Entity is part of, as array of {relation, position, role}, sorted by position. */
 379             public function get memberships():Array {
 380                         var list:Array=[];
 381                         for (var o:Object in parents) {
 382                                 if (o is Relation) {
 383                                         for (var i:uint=0; i<o.length; i++) {
 384                                                 if (o.getMember(i).entity==this) {
 385                                                         list.push( { relation:o, position:i, role: o.getMember(i).role } );
 386                                                 }
 387                                         }
 388                                 }
 389                         }
 390             // it's useful to return in a sorted order, even if the relations are interleaved
 391             // e.g. [{r0 p1},{r1 p1},{r0 p4}]
 392                         return list.sortOn("position");
 393                 }
 394
 395
 396
 397                 /** Temporarily prevent redrawing of the object. */
 398                 public function suspend():void {
 399                         dispatchEvent(new EntityEvent(Connection.SUSPEND_REDRAW, this));
 400                 }
 401                 /** Resume redrawing of the object */
 402                 public function resume():void {
 403                         dispatchEvent(new EntityEvent(Connection.RESUME_REDRAW, this));
 404                 }
 405
 406
 407                 /** Basic description of Entity - should be overriden by subclass. */
 408                 public function getDescription():String {
 409                         var basic:String=this.getType()+" "+_id;
 410                         if (tags['ref'] && tags['name']) { return tags['ref']+' '+tags['name']+' ('+basic+')'; }
 411                         if (tags['ref']) { return tags['ref']+' ('+basic+')'; }
 412                         if (tags['name']) { return tags['name']+' ('+basic+')'; }
 413                         return basic;
 414                 }
 415
 416         /** The type of Entity (node, way etc). By default, returns ''. */
 417         public function getType():String {
 418             return '';
 419         }
 420
 421                 /** Compare type against supplied string */
 422                 public function isType(str:String):Boolean {
 423                         return getType()==str;
 424                 }
 425
 426         /** Copy tags from another entity into this one, creating "key=value1; value2" pairs if necessary.
 427         * * @return Array of keys that require manual merging, in order to warn the user. */
 428         public function mergeTags(source: Entity, performAction:Function):Boolean {
 429             var sourcetags:Object = source.getTagsHash();
 430             var conflict:Boolean = false;
 431             for (var k:String in sourcetags) {
 432                 var v1:String = tags[k];
 433                 var v2:String = sourcetags[k];
 434                 if ( v1 && v1 != v2) {
 435                     setTag(k, v1+"; "+v2, performAction);
 436                     conflict=true;
 437                 } else {
 438                     setTag(k, v2, performAction);
 439                 }
 440             }
 441             return conflict;
 442         }
 443
 444     }
 445
 446 }
 447