Method: removeMap
Unbinds this instance from a map

Parameters:
map - {<OpenLayers.Map>}
325563
function(map) {
        if (this._destroyed || !OpenLayers.Layer.Grid) {
            return;
        }
        window.clearTimeout(this.tileQueueId[map.id]);
        if (map.layers) {
            for (var i=0, ii=map.layers.length; i<ii; ++i) {
                this.removeLayer({layer: map.layers[i]});
            }
        }
        if (map.events) {
            map.events.un({
                move: this.move,
                zoomend: this.zoomEnd,
                changelayer: this.changeLayer,
                addlayer: this.addLayer,
                preremovelayer: this.removeLayer,
                scope: this
            });
        }
        delete this.tileQueue[map.id];
        delete this.tileQueueId[map.id];
        OpenLayers.Util.removeItem(this.maps, map);
    }
89443
public static <L, K> void removeListener (Map<K, ListenerList<L>> map, K key, L listener)
    {
        ListenerList<L> list = map.get(key);
        if (list != null) {
            list.remove(listener);
        }
    }
172743
function(map) {
        this.dragControl.setMap(map);
        OpenLayers.Control.prototype.setMap.apply(this, arguments);
    }
42163
@Override
  protected boolean removeMapping(Object o) {
    Lock l = writeLock();
    l.lock();
    try {
      return super.removeMapping(o);
    } finally {
      l.unlock();
    }
  }
788066
function(map) {
        OpenLayers.Control.prototype.setMap.apply(this, arguments);

        this.map.events.on({
            addlayer: this.redraw,
            changelayer: this.redraw,
            removelayer: this.redraw,
            changebaselayer: this.redraw,
            scope: this
        });
        if (this.outsideViewport) {
            this.events.attachToElement(this.div);
            this.events.register("buttonclick", this, this.onButtonClick);
        } else {
            this.map.events.register("buttonclick", this, this.onButtonClick);
        }
    }
186481
function(map) {
        if (this._destroyed || !OpenLayers.Layer.Grid) {
            return;
        }
        this.maps.push(map);
        this.tileQueue[map.id] = [];
        for (var i=0, ii=map.layers.length; i<ii; ++i) {
            this.addLayer({layer: map.layers[i]});
        }
        map.events.on({
            move: this.move,
            zoomend: this.zoomEnd,
            changelayer: this.changeLayer,
            addlayer: this.addLayer,
            preremovelayer: this.removeLayer,
            scope: this
        });
    }
263919
@Override
    public void removeMapping(int pos) {
        for (int i = pos; i < mappingCount - 1; i++) {
            map[i] = map[i + 1];
        }
        map[mappingCount - 1] = null;
        mappingCount--;
        notifyChanged();
    }
889007
function(object) {
            this.map.remove(object.x, object.y);
            var index = this.objects.indexOf(object);
            this.objects.splice(index, 1);
            if(object.onRemove){
                object.onRemove();
            }
        }
751173
public function removeMapping(ImsManifestMapping $mapping)
    {
        $mappings = $this->getMappings();

        if (($key = array_search($mapping, $mappings, true)) !== false) {
            unset($mappings[$key]);
        }
    }
617075
public static <V> Map<String, V> cleanupMap(Map<String, V> map) {
        if (map == null || map.isEmpty()) {
            return null;
        }

        Map<String, V> result = new HashMap<String, V>(map.size());
        Set<Entry<String, V>> entries = map.entrySet();

        for (Entry<String, V> entry : entries) {
            if (entry.getValue() != null) {
                result.put(entry.getKey(), entry.getValue());
            }
        }

        return result;
    }
1222165
def _delete_map_from_user_by_id(self, user, map_id):
        
        map = self._get_map_from_user_by_id(user, map_id)
        if map is None:
            return None
        Session.delete(map)
        Session.commit()
        return map
1100705
private Map<String, Object> removeUnusedMapEntries(
            AtlasVertex instanceVertex, String propertyName,
            Map<String, Object> currentMap,
            Map<String, Object> newMap, IDataType elementType,
            AttributeInfo attributeInfo)
                    throws AtlasException {

        Map<String, Object> additionalMap = new HashMap<>();
        for (String currentKey : currentMap.keySet()) {

            boolean shouldDeleteKey = !newMap.containsKey(currentKey);
            if (GraphHelper.isReference(elementType)) {

                //Delete the edge reference if its not part of new edges created/updated
                AtlasEdge currentEdge = (AtlasEdge)currentMap.get(currentKey);

                if (!newMap.values().contains(currentEdge)) {

                    boolean deleted =
                            deleteHandler.deleteEdgeReference(currentEdge, elementType.getTypeCategory(), attributeInfo.isComposite, true);
                    if (!deleted) {
                        additionalMap.put(currentKey, currentEdge);
                        shouldDeleteKey = false;
                    }
                }
            }

            if (shouldDeleteKey) {
                String propertyNameForKey = GraphHelper.getQualifiedNameForMapKey(propertyName, currentKey);
                GraphHelper.setProperty(instanceVertex, propertyNameForKey, null);
            }
        }
        return additionalMap;
    }
563453
public static void unmapByteBuffer(final MappedByteBuffer map) {
    if(map == null) {
      return;
    }
    map.force();
    try {
      if(Runtime.class.getDeclaredMethod("version") != null)
        return; // At later Java, the hack below will not work anymore.
    }
    catch(NoSuchMethodException e) {
      // This is an ugly hack, but all that Java <8 offers to help freeing
      // memory allocated using such buffers.
      // See also: http://bugs.sun.com/view_bug.do?bug_id=4724038
      AccessController.doPrivileged(new PrivilegedAction<Object>() {
        @Override
        public Object run() {
          try {
            Method getCleanerMethod = map.getClass().getMethod("cleaner", new Class[0]);
            if(getCleanerMethod == null) {
              return null;
            }
            getCleanerMethod.setAccessible(true);
            Object cleaner = getCleanerMethod.invoke(map, new Object[0]);
            Method cleanMethod = cleaner.getClass().getMethod("clean");
            if(cleanMethod == null) {
              return null;
            }
            cleanMethod.invoke(cleaner);
          }
          catch(Exception e) {
            LoggingUtil.exception(e);
          }
          return null;
        }
      });
    }
    catch(SecurityException e1) {
      // Ignore.
    }
  }
151738
def unload():
        """"""
        global __tile_maps
        global active_map
        if TileMapManager.active_map != None:
            world = Ragnarok.get_world()

            for obj in TileMapManager.active_map.objects:
                world.remove_obj(obj)
            world.remove_obj(TileMapManager.active_map)
1136362
private void removeMapping() {
		int[] indexes = mappingList.getSelectedIndices();
		if (indexes == null) {
			return;
		}
		int confirm = JOptionPane.showConfirmDialog(
				this, 
				"Proceed deleting " + indexes.length + " mappings?", "Conform",
				JOptionPane.WARNING_MESSAGE, JOptionPane.YES_NO_OPTION);
		if (confirm == JOptionPane.CANCEL_OPTION || confirm == JOptionPane.CLOSED_OPTION) {
			return;
		}
		
		// The manager panel can handle multiple deletions.
		Object[] values = mappingList.getSelectedValues();

		OBDAModel controller = apic;
		URI srcuri = selectedSource.getSourceID();

		for (int i = 0; i < values.length; i++) {
			SQLPPTriplesMap mapping = (SQLPPTriplesMap) values[i];
			if (mapping!=null)
			controller.removeTriplesMap(srcuri, mapping.getId());
		}
		mappingList.clearSelection();
	}
912163
public static <K, V> void clear(Map<K, V> map) {
        if (map != null) {
            map.clear();
        }
    }
558604
function() {
        if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
            this.map.events.unregister('moveend', this, this.update);
            this.map.removeLayer(this.gratLayer);
            return true;
        } else {
            return false;
        }
    }