Deletes all points within a given area and updates the meta data.
498985
def delete_area(area)
      reset_meta_data
      segments.each do |seg|
        seg.delete_area(area)
        update_meta_data(seg) unless seg.empty?
      end
      segments.delete_if(&:empty?)
    end
976913
public void clear()
    {
        DelaunayTriangle t;
        for( int i=0; i<3; i++ )
        {
            t = neighbors[i];
            if( t != null )
            {
                t.clearNeighbor( this );
            }
        }
        clearNeighbors();
        points[0]=points[1]=points[2]=null;
    }
1126145
def forget_area(self, area_uuid):
        
        if self._config.upload.current_area == area_uuid:
            self._config.upload.current_area = None
        if area_uuid in self._config.upload.areas:
            del self._config.upload.areas[area_uuid]
            self.save()
1340712
public void removeArea(final Section AREA) {
        if (null == AREA) return;
        areas.remove(AREA);
        Collections.sort(areas, new SectionComparator());
        fireUpdateEvent(SECTION_EVENT);
    }
1192979
def clear(self):
        
        for f in [x['content'] for x in self.metadata.values()]:
            os.remove(f)

        self.metadata = {}
        self._flush()
866103
def clear(self):
        
        for sample in self.metadata:
            try:
                delattr(sample.depth, 'bases')
                delattr(sample.depth, 'coverage')
                delattr(sample.depth, 'length')
                delattr(sample.depth, 'stddev')
            except AttributeError:
                pass
222901
def perform_partial_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
795677
function deleteFn(point) {
	if (point && typeof(point) === 'string') {
		const tree = point.split('.');
		let source = goblin.db;

		return tree.every((node, i) => {
			if (source[node] === undefined) {
				logger('DB_DELETE_INVALID_POINT', node);
				return false;
			}

			if (i === tree.length - 1) {
				let oldValue = source[node];

				if (Array.isArray(source)) {
					source.splice(node, 1);
					return true;
				}

				if (delete source[node]) {
					goblin.goblinDataEmitter.emit('change', {
						type: 'delete',
						value: undefined,
						oldValue: oldValue
					});

					return true;
				} else {
					return false;
				}
			}

			source = source[node];
			return true;
		});
	}

	logger('DB_DELETE_MISSING_POINT');
	return false;
}
1092783
def clear(self):
        """"""
        self.tool.reset()
        self._populate_coordinates()
        # Revert to using hazard, exposure and view as basis for analysis
        self.hazard_exposure_view_extent.setChecked(True)
122719
def cleanup(self):
        """"""
        for item in self.server_map:
            self.member_del(item, reconfig=False)
        self.server_map.clear()
1065465
def delete_all
      raise "not yet used"
      len = @data.length-1
      @data=[]
      tme = TreeModelEvent.new(0, len,:ALL_COLUMNS,  self, :DELETE)
      fire_handler :TREE_MODEL_EVENT, tme
    end
872912
public function deletePoint($pointIndex = 0, $partIndex = 0)
    {
        switch ($this->shapeType) {
            case 0:
                //Don't delete anything
                break;
            case 1:
            case 11:
            case 21:
                //Sets the value of the point to zero
                $this->SHPData['x'] = 0.0;
                $this->SHPData['y'] = 0.0;
                if (in_array($this->shapeType, [11, 21])) {
                    $this->SHPData['m'] = 0.0;
                }
                if (in_array($this->shapeType, [11])) {
                    $this->SHPData['z'] = 0.0;
                }
                break;
            case 3:
            case 5:
            case 13:
            case 15:
            case 23:
            case 25:
                //Deletes the point from the selected part, if exists
                if (isset($this->SHPData['parts'][$partIndex]) && isset($this->SHPData['parts'][$partIndex]['points'][$pointIndex])) {
                    $count = count($this->SHPData['parts'][$partIndex]['points']) - 1;
                    for ($i = $pointIndex; $i < $count; ++$i) {
                        $this->SHPData['parts'][$partIndex]['points'][$i] = $this->SHPData['parts'][$partIndex]['points'][$i + 1];
                    }
                    unset($this->SHPData['parts'][$partIndex]['points'][count($this->SHPData['parts'][$partIndex]['points']) - 1]);

                    $this->SHPData['numparts'] = count($this->SHPData['parts']);
                    --$this->SHPData['numpoints'];
                }
                break;
            case 8:
            case 18:
            case 28:
                //Deletes the point, if exists
                if (isset($this->SHPData['points'][$pointIndex])) {
                    $count = count($this->SHPData['points']) - 1;
                    for ($i = $pointIndex; $i < $count; ++$i) {
                        $this->SHPData['points'][$i] = $this->SHPData['points'][$i + 1];
                    }
                    unset($this->SHPData['points'][count($this->SHPData['points']) - 1]);

                    --$this->SHPData['numpoints'];
                }
                break;
            default:
                $this->setError(sprintf('The Shape Type "%s" is not supported.', $this->shapeType));
                break;
        }
    }
409596
public void remove(int p) {
        npoints--;
        int q = index[p];
        index[points[q] = points[npoints]] = q;

        for (int i = 0; i < npoints; i++) {
            if (neighbor[points[i]] == p) {
                findNeighbor(points[i]);
            }
        }
    }
3398
public function removeArea(Area $area)
    {
        if ($this->areas->contains($area)) {
            $this->areas->removeElement($area);
        }
    }
1151442
private void updateRemove()
    {
        if (willDelete)
        {
            for (final Integer id : toDelete)
            {
                final Featurable featurable = featurables.get(id);
                for (final HandlerListener listener : listeners)
                {
                    listener.notifyHandlableRemoved(featurable);
                }
                featurable.getFeature(Identifiable.class).notifyDestroyed();
                featurables.remove(featurable, id);
            }
            toDelete.clear();
            willDelete = false;
        }
    }
1335206
public void removeArea(final TimeSection AREA) {
        if (null == AREA) return;
        areas.remove(AREA);
        Collections.sort(areas, new TimeSectionComparator());
        fireUpdateEvent(SECTION_EVENT);
    }
814689
def clear_database(self):
        
        self.logger.info('Removing obsolete geoip from database...')
        IpRange.objects.all().delete()
        City.objects.all().delete()
        Region.objects.all().delete()
        Country.objects.all().delete()