Simplified method form for invoking the DeleteTopic operation with an AsyncHandler.

@see #deleteTopicAsync(DeleteTopicRequest, com.amazonaws.handlers.AsyncHandler)
553753
@Override
    public java.util.concurrent.Future<DeleteTopicResult> deleteTopicAsync(String topicArn,
            com.amazonaws.handlers.AsyncHandler<DeleteTopicRequest, DeleteTopicResult> asyncHandler) {

        return deleteTopicAsync(new DeleteTopicRequest().withTopicArn(topicArn), asyncHandler);
    }
723799
public void deleteSeen(SITransaction simpTran)
  throws SISessionUnavailableException, SISessionDroppedException,
         SIIncorrectCallException,
         SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "deleteSeen", 
        new Object[] { this, simpTran });        
      
    deleteCurrent(simpTran);
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "deleteSeen");
  }
1186017
@Override
  public Task<Void> deleteApiKey(@NonNull final ObjectId id) {
    return dispatcher.dispatchTask(new Callable<Void>() {
      @Override
      public Void call() {
        deleteApiKeyInternal(id);
        return null;
      }
    });
  }
649637
public boolean deleteSinkAsync(String sinkName) throws ExecutionException, InterruptedException {
    // [START deleteSinkAsync]
    Future<Boolean> future = logging.deleteSinkAsync(sinkName);
    // ...
    boolean deleted = future.get();
    if (deleted) {
      // the sink was deleted
    } else {
      // the sink was not found
    }
    // [END deleteSinkAsync]
    return deleted;
  }
12401
@Override
	public final void deleteTemporaryTopic(String topicName) throws JMSException
    {
        engine.deleteTopic(topicName);
        unregisterTemporaryTopic(topicName);
    }
525660
public void delete() throws IOException, PlivoRestException {
    validate();
    Response<ResponseBody> response = obtainCall().execute();

    handleResponse(response);
  }
934185
public void delete() 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "delete");
    
    

    // Mark the destination for deletion
    try
    {
      // Set the deletion flag in the DH persistently. A transaction per DH??
      LocalTransaction siTran = txManager.createLocalTransaction(true);

      setToBeDeleted(true);
      
      // Adjust the destination lookups in Destination Manager
      destinationManager.getLinkIndex().delete(this);
      
      requestUpdate((Transaction) siTran);
      // commit the transaction
      siTran.commit();
      
      String name = _mqLinkName;
      if (name == null)      
        name = getName();
      SibTr.info(tc, "MQLINK_DEST_DELETE_INFO_CWSIP0064", 
                   new Object[]{name, _mqLinkUuid});   
    }
    catch (MessageStoreException e)
    {
      // No FFDC code needed
      
      SibTr.exception(tc, e);
      
      //throw e;
    }
    catch (SIException e)
    {
      // No FFDC code needed
      
      SibTr.exception(tc, e);
       
      //handleRollback(siTran);
      //        throw e;
    }    

    // Now start the asynch deletion thread to tidy up
    destinationManager.startAsynchDeletion();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "delete");        
  }
1347098
public Observable<Void> deleteIterationAsync(UUID projectId, UUID iterationId) {
        return deleteIterationWithServiceResponseAsync(projectId, iterationId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }
1197709
public CompletableFuture<Void> delete() {
    return server.stop().thenCompose(v -> client.stop()).thenRun(() -> {
      if (server != null) {
        server.delete();
      }
    });
  }
368400
@Override
    public java.util.concurrent.Future<DeleteStreamResult> deleteStreamAsync(String streamName,
            com.amazonaws.handlers.AsyncHandler<DeleteStreamRequest, DeleteStreamResult> asyncHandler) {

        return deleteStreamAsync(new DeleteStreamRequest().withStreamName(streamName), asyncHandler);
    }
917986
public void delete(Integer expectedResponseCode) throws IOException {
    HttpURLConnection conn = getUrlConnection();
    try {
      if (!NetworkUtils.sendHttpDeleteRequest(conn)) {
        throw new IOException("Failed to send delete request to " + endpointURI);
      }

      // Check the response code
      if (!NetworkUtils.checkHttpResponseCode(conn, expectedResponseCode)) {
        throw new IOException("Unexpected response from connection. Expected "
            + expectedResponseCode + " but received " + conn.getResponseCode());
      }
    } finally {
      conn.disconnect();
    }
  }
1093892
@Override
    public java.util.concurrent.Future<DescribeDestinationsResult> describeDestinationsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeDestinationsRequest, DescribeDestinationsResult> asyncHandler) {

        return describeDestinationsAsync(new DescribeDestinationsRequest(), asyncHandler);
    }
302971
@Override
    public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(String queueUrl, String receiptHandle,
            com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, DeleteMessageResult> asyncHandler) {

        return deleteMessageAsync(new DeleteMessageRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle), asyncHandler);
    }
262703
@Override
    public java.util.concurrent.Future<CancelImportTaskResult> cancelImportTaskAsync(
            com.amazonaws.handlers.AsyncHandler<CancelImportTaskRequest, CancelImportTaskResult> asyncHandler) {

        return cancelImportTaskAsync(new CancelImportTaskRequest(), asyncHandler);
    }
1184336
@Override
    public final <RS> Maybe<Response<RS>> delete(String resource, Class<RS> clazz)
            throws RestEndpointIOException {
        HttpDelete delete = new HttpDelete(spliceUrl(resource));
        return executeInternal(delete, new ClassConverterCallback<RS>(serializers, clazz));
    }
449605
@Override
    public java.util.concurrent.Future<DeleteItemResult> deleteItemAsync(String tableName, java.util.Map<String, AttributeValue> key,
            com.amazonaws.handlers.AsyncHandler<DeleteItemRequest, DeleteItemResult> asyncHandler) {

        return deleteItemAsync(new DeleteItemRequest().withTableName(tableName).withKey(key), asyncHandler);
    }
553478
@Override
    public java.util.concurrent.Future<ListSubscriptionsByTopicResult> listSubscriptionsByTopicAsync(String topicArn,
            com.amazonaws.handlers.AsyncHandler<ListSubscriptionsByTopicRequest, ListSubscriptionsByTopicResult> asyncHandler) {

        return listSubscriptionsByTopicAsync(new ListSubscriptionsByTopicRequest().withTopicArn(topicArn), asyncHandler);
    }