Execute a DELETE request.
@param uri The URI to call
@param headers A set of headers to add to the request
@param queryParams A set of query parameters to add to the request
489500
protected void executeDeleteRequest(URI uri, Map<String, Object> headers, 
        List<String> queryParams)
    {
        WebTarget target = this.client.target(uri);
        target = applyQueryParams(target, queryParams);
        Invocation.Builder invocation = target.request(MediaType.APPLICATION_JSON);
        applyHeaders(invocation, headers);
        Response response = invocation.delete();
        handleResponseError("DELETE", uri, response);
        logResponse(uri, response);
    }
1333956
public RestResponse delete(final String uri) throws IOException, AppPlatformException {
        return request(getPath(uri), HttpDelete.METHOD_NAME);
    }
1212213
@Deprecated
  public void deleteByQuery(Query query, RequestOptions requestOptions) throws AlgoliaException {
    this.deleteByQuery(query, 100000, requestOptions);
  }
1100633
public static RequestResponse callHttpDelete(HttpJsonRpcClient client, String url,
            Map<String, Object> headers, Map<String, Object> urlParams) {
        return client.doDelete(url, headers, urlParams);
    }
1231955
def delete(self, uri, query=None, **kwargs):
        """"""
        return self.fetch('delete', uri, query, **kwargs)
763522
public void processHeaderParams(Map<String, String> headerParams, Request.Builder reqBuilder) {
        for (Entry<String, String> param : headerParams.entrySet()) {
            reqBuilder.header(param.getKey(), parameterToString(param.getValue()));
        }
        for (Entry<String, String> header : defaultHeaderMap.entrySet()) {
            if (!headerParams.containsKey(header.getKey())) {
                reqBuilder.header(header.getKey(), parameterToString(header.getValue()));
            }
        }
    }
263014
@InterfaceAudience.Public
    public void setHeaders(Map<String, Object> requestHeadersParam) {
        if (requestHeadersParam != null && !requestHeaders.equals(requestHeadersParam)) {
            requestHeaders = requestHeadersParam;
        }
    }
402715
def _deleter(self, uri, headers):
        

        # perform Object HEAD request
        resp = self.http.delete(url=uri, headers=headers)
        self._resp_exception(resp=resp)
        return resp
1077377
public void updateParamsForAuth(String[] authNames, List<Pair> queryParams, Map<String, String> headerParams) {
        for (String authName : authNames) {
            Authentication auth = authentications.get(authName);
            if (auth == null) throw new RuntimeException("Authentication undefined: " + authName);
            auth.applyToParams(queryParams, headerParams);
        }
    }
499605
public function deleteResource(
        $uri = '',
        $headers = []
    ) {
        $options = ['http_errors' => false, 'headers' => $headers];

        return $this->client->request(
            'DELETE',
            $uri,
            $options
        );
    }
1350302
public static Response delete(String url, Map<String, String> query) throws HttpException {

		return delete(url, query, null, DEFAULT_CONNECT_TIMEOUT, DEFAULT_READ_TIMEOUT);
	}
738153
public void doHead(String url, HttpResponse response, Map<String, Object> headers) {
        response.setRequest(url);
        httpClient.head(url, response, headers);
    }
497072
@RequestMapping(value = "/delete", method = RequestMethod.POST)
	public @ResponseBody
	void delete(
			@RequestParam(value = "username", required = true) String username,
			HttpServletResponse response) {
		logger.debug("Received request to delete account");

		ResponseAccount responseAccount = accountService
				.getAccountByUsername(username);
		if (responseAccount.getAccount() == null) {
			try {
				response.sendError(500, "No such user exists: " + username);
			} catch (IOException e) {
				e.printStackTrace();
				return;
			}
			return;
		}
		accountService.delete(responseAccount.getAccount());

	}
395824
def delete(self, action, headers=None):
        
        return self.request(make_url(self.endpoint, action), method='DELETE',
                            headers=headers)
155592
public NextResponse delete(final String url, final Map<String, String> queries,
                               final Map<String, String> headers)
            throws IOException {
        return request(HttpMethod.DELETE, url, queries, null, headers);
    }
136461
private HttpResponse executeDelete(String bucketName, String objectName, Map<String,String> queryParamMap)
    throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
           InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
           InternalException {
    HttpResponse response = execute(Method.DELETE, getRegion(bucketName), bucketName, objectName, null,
                                    queryParamMap, null, 0);
    response.body().close();
    return response;
  }
256939
public String delete(String endpoint, String params) throws IOException {
        return this.delete(endpoint, params, "");
    }