region > delete (action)
509194
@Programmatic
    public List<SomeAuditedObject> delete(final SomeAuditedObject object) {
        repositoryService.remove(object);
        transactionService.flushTransaction();
        return listAll();
    }
199975
def delete(self, response, **kwargs):
        '''
        
        '''
        response_cls = self._get_instance(**kwargs)
        if response_cls:
            _action_and_commit(response_cls, session.delete)
794590
@Override
	public void removeActions(String nodeID) {

		// Stop local services
		if (this.nodeID.equals(nodeID)) {
			stopAllLocalServices();
		}

		// Remove actions
		final long stamp = lock.writeLock();
		try {
			Iterator<Strategy<ActionEndpoint>> endpoints = strategies.values().iterator();
			while (endpoints.hasNext()) {
				Strategy<ActionEndpoint> strategy = endpoints.next();
				strategy.remove(nodeID);
				if (strategy.isEmpty()) {
					endpoints.remove();
				}
			}

			// Update service names
			names.clear();
			names.addAll(strategies.keySet());

			// Delete cached node descriptor
			if (this.nodeID.equals(nodeID)) {
				clearDescriptorCache();
			}

		} finally {
			lock.unlockWrite(stamp);
		}

		// Reject promises
		Iterator<PendingPromise> pendingPromises = promises.values().iterator();
		boolean removed = false;
		while (pendingPromises.hasNext()) {
			PendingPromise pending = pendingPromises.next();
			if (pending.nodeID.equals(nodeID)) {
				removed = true;
				pendingPromises.remove();
				executor.execute(() -> {
					try {
						pending.promise.complete(new RequestRejectedError(nodeID, pending.action));
					} catch (Throwable cause) {
						logger.warn("Unable to reject action \"" + pending.action + "\"!", cause);
					}
				});
			}
		}

		// Reschedule timeout checker
		if (removed) {
			scheduler.execute(() -> {
				reschedule(Long.MAX_VALUE);
			});
		}

		// Notify listeners
		if (this.nodeID.equals(nodeID)) {

			// Notify local listeners (LOCAL services changed)
			broadcastServicesChanged(true);
		} else {

			// Notify local listeners (REMOTE services changed)
			broadcastServicesChanged(false);
		}
	}
268915
public Observable<Void> deleteImageRegionsAsync(UUID projectId, List<String> regionIds) {
        return deleteImageRegionsWithServiceResponseAsync(projectId, regionIds).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }
125997
def delete_action(plugin, action_id)
      the_plugin = hawk_escape plugin
      the_action_id = hawk_escape action_id
      http_delete "/actions/#{the_plugin}/#{the_action_id}"
    end
199571
public static void actionDelete(PageContext pc, Resource dir, boolean forceDelete, String serverPassword) throws PageException {
	SecurityManager securityManager = pc.getConfig().getSecurityManager();
	securityManager.checkFileLocation(pc.getConfig(), dir, serverPassword);

	// directory doesn't exist
	if (!dir.exists()) {
	    if (dir.isDirectory()) throw new ApplicationException("directory [" + dir.toString() + "] doesn't exist");
	    else if (dir.isFile()) throw new ApplicationException("file [" + dir.toString() + "] doesn't exist and isn't a directory");
	}

	// check if file
	if (dir.isFile()) throw new ApplicationException("can't delete [" + dir.toString() + "], it isn't a directory it is a file");

	// delete directory
	try {
	    dir.remove(forceDelete);
	}
	catch (IOException e) {
	    throw Caster.toPageException(e);
	}
    }
956629
function deleteLambda(region) {
  const regionKey = getRegionKey(region);
  if (regionKey) {
    lambdaOptionsByRegionKey.delete(regionKey);
    return lambdaByRegionKey.delete(regionKey);
  }
  return false;
}
1067787
private void btDeleteActionPerformed(java.awt.event.ActionEvent evt)//GEN-FIRST:event_btDeleteActionPerformed
    {//GEN-HEADEREND:event_btDeleteActionPerformed

      int row = tableList.getSelectedRow();
      int col = tableModel.findColumn("id");

      if(row > -1 && col > -1)
      {
        Object value = tableModel.getValueAt(row, col);
        final LinkedList<Long> corpusListToDelete = new LinkedList<Long>();
        long l = Long.parseLong(value.toString());
        corpusListToDelete.add(l);

        pbDelete.setIndeterminate(true);
        btClose.setEnabled(false);
        btDelete.setEnabled(false);

        SwingWorker<String, Void> worker = new SwingWorker<String, Void>()
        {

          @Override
          protected String doInBackground() throws Exception
          {
            corpusAdmin.deleteCorpora(corpusListToDelete);
            updateTable();
            return "";
          }

          @Override
          protected void done()
          {
            pbDelete.setIndeterminate(false);
            pbDelete.setValue(100);
            btClose.setEnabled(true);
            btDelete.setEnabled(true);
          }
        };

        worker.execute();

      }

    }
1222693
public function deleteAction()
    {
        $request = $this->getRequest();

        $model = $this->getModel();
        $model->applyRequest($request);

        if ($model->getFilter()) {
            $model->delete();
        } else {
            $this->addMessage($this->_('Empty delete request not allowed'));
        }
        $this->_reroute(array($request->getActionKey() => 'index', MUTil_Model::REQUEST_ID => null));
    }
60232
public Observable<ServiceResponse<Void>> deleteImageRegionsWithServiceResponseAsync(UUID projectId, List<String> regionIds) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (regionIds == null) {
            throw new IllegalArgumentException("Parameter regionIds is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        Validator.validate(regionIds);
        String regionIdsConverted = this.client.serializerAdapter().serializeList(regionIds, CollectionFormat.CSV);
        return service.deleteImageRegions(projectId, regionIdsConverted, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteImageRegionsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
519861
@Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int result = -1;

        if (!controller.hasPreinitialized()) {
            throw new IllegalStateException("Controller has not been initialized.");
        }

        int patternCode = controller.getUriMatcher().match(uri);
        MatcherPattern pattern = controller.findMatcherPattern(patternCode);
        if (pattern == null) {
            throw new IllegalArgumentException("unknown uri : " + uri.toString());
        }

        Parameter parameter = new Parameter(uri, selection, selectionArgs);
        SQLiteDatabase db = this.getHelper().getWritableDatabase();

        result = onDelete(this.getHelper(), db, pattern, parameter);
        if (result >= 0) {
            this.onDeleteCompleted(result, uri, pattern, parameter);
        }
        return result;
    }
270992
public function deleteAction() {
        try {
            if(sizeOf($this->dispatcher->getParams()) == 0) {
                throw new Exception('Invalid Entity Id Passed In', 400);
            }
            $entity = $this->validateEntityId($this->dispatcher->getParam(0));
            $this->deleteActionInternal($entity);
        } catch(Exception $e) {
            $this->handleError($e);
        } catch(ValidationException $e) {
            $this->handleValidationError($e);
        } catch(AclException $e) {
            $this->handleAclError($e);
        }
    }
1127276
void executeAction( Action action ) throws PluginException {

		try {
			switch( action.actionType ) {
			case DELETE:
				this.logger.fine( "Deleting " + action.parameter + "..." );
				File f = new File( action.parameter );
				Utils.deleteFilesRecursively( f );
				break;

			case DOWNLOAD:
				this.logger.fine( "Downloading " + action.parameter + "..." );
				URI uri = UriUtils.urlToUri( action.parameter );
				File targetFile = new File( System.getProperty( "java.io.tmpdir" ), TMP_FILE );
				InputStream in = null;
				try {
					in = uri.toURL().openStream();
					Utils.copyStream( in, targetFile );

				} finally {
					Utils.closeQuietly( in );
				}

				break;

			case MOVE:
				List<String> parts = Utils.splitNicely( action.parameter, "->" );
				if( parts.size() != 2 ) {
					this.logger.warning( "Invalid syntax for 'move' action. " + action.parameter );
				} else {
					File source = new File( parts.get( 0 ));
					File target = new File( parts.get( 1 ));
					this.logger.fine( "Moving " + source + " to " + target + "..." );
					if( ! source.renameTo( target ))
						throw new IOException( source + " could not be moved to " + target );
				}

				break;

			case COPY:
				parts = Utils.splitNicely( action.parameter, "->" );
				if( parts.size() != 2 ) {
					this.logger.warning( "Invalid syntax for 'copy' action. " + action.parameter );
				} else {
					File source = new File( parts.get( 0 ));
					File target = new File( parts.get( 1 ));
					this.logger.fine( "Copying " + source + " to " + target + "..." );
					Utils.copyStream( source, target );
				}

				break;

			default:
				this.logger.fine( "Ignoring the action..." );
				break;
			}

		} catch( Exception e ) {
			throw new PluginException( e );
		}
	}
235358
public DeleteAction delete(String... values) {
        return new DeleteAction(this, new LiteralOperand(
                new LinkedHashSet<String>(Arrays.asList(values))));
    }
1136669
public void setAction(String action) throws ApplicationException {
	action = action.toLowerCase().trim();
	if (action.equals("getall")) this.action = ACTION_GET_ALL;
	else if (action.equals("get")) this.action = ACTION_GET;
	else if (action.equals("set")) this.action = ACTION_SET;
	else if (action.equals("delete")) this.action = ACTION_DELETE;
	else throw new ApplicationException("attribute action of the tag registry has an invalid value [" + action + "], valid values are [getAll, get, set, delete]");
    }
1284214
@Override
    public void actionPerformed(ActionEvent e) {
        String cmd = e.getActionCommand();
        if (cmd.equals("Cut")) {
            // textArea.cut();
        } else if (cmd.equals("Copy")) {
            textArea.copy();
        } else if (cmd.equals("Paste")) {
            // textArea.paste();
        }
    }
978231
public void delete(String title, String reason) {
    getPerformedAction(new PostDelete(getUserinfo(), title, reason));
  }