Handles "deleteRouteTable" request to delete routetable and returns response with a route table.
@param routeTableId Route table Id.
@return a CreateRouteTableResponseType with route table
172924
private DeleteRouteTableResponseType deleteRouteTable(final String routeTableId) {
        DeleteRouteTableResponseType ret = new DeleteRouteTableResponseType();
        ret.setRequestId(UUID.randomUUID().toString());
        mockRouteTableController.deleteRouteTable(routeTableId);
        return ret;
    }
248517
@Override
    public java.util.concurrent.Future<DeleteTableResult> deleteTableAsync(String tableName) {

        return deleteTableAsync(new DeleteTableRequest().withTableName(tableName));
    }
828708
public synchronized void remove(int requestId)
   {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");
		
      if (!containsId(requestId))
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) debugTraceTable("id ("+requestId+") not in table");
         throw new SIErrorException(nls.getFormattedMessage("REQIDTABLE_INTERNAL_SICJ0058", null, "REQIDTABLE_INTERNAL_SICJ0058")); // D226223
      }

      testReqIdTableEntry.requestId = requestId;
      table.remove(testReqIdTableEntry);

		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove");
   }
813300
private DescribeRouteTablesResponseType describeRouteTables() {
        DescribeRouteTablesResponseType ret = new DescribeRouteTablesResponseType();
        ret.setRequestId(UUID.randomUUID().toString());

        RouteTableSetType routeTableSet = new RouteTableSetType();
        for (Iterator<MockRouteTable> mockRouteTable = mockRouteTableController
                .describeRouteTables().iterator(); mockRouteTable.hasNext();) {
            MockRouteTable item = mockRouteTable.next();

            RouteTableType routeTable = new RouteTableType();
            if (!DEFAULT_MOCK_PLACEMENT.getAvailabilityZone().equals(currentRegion)) {
                routeTable.setVpcId(currentRegion + "_" + item.getVpcId());
                routeTable.setRouteTableId(currentRegion + "_" + item.getRouteTableId());
            } else {
                routeTable.setVpcId(item.getVpcId());
                routeTable.setRouteTableId(item.getRouteTableId());
            }

            RouteTableAssociationSetType associationSet = new RouteTableAssociationSetType();
            routeTable.setAssociationSet(associationSet);

            RouteSetType routeSet = new RouteSetType();
            routeTable.setRouteSet(routeSet);

            routeTableSet.getItem().add(routeTable);
        }

        ret.setRouteTableSet(routeTableSet);

        return ret;
    }
254654
private GetRouteResponse getRoutes(GetRouteRequest getRouteRequest) {
        checkNotNull(getRouteRequest, "route request should not be null");
        if (Strings.isNullOrEmpty(getRouteRequest.getRouteTableId())
                && Strings.isNullOrEmpty(getRouteRequest.getVpcId())) {
            throw new IllegalArgumentException("routeTableId and vpcId cannot be empty at the same time");
        }
        InternalRequest internalRequest = this.createRequest(
                getRouteRequest, HttpMethodName.GET, ROUTE_PREFIX);
        if (!Strings.isNullOrEmpty(getRouteRequest.getVpcId())) {
            internalRequest.addParameter("vpcId", getRouteRequest.getVpcId());
        }
        else if (!Strings.isNullOrEmpty(getRouteRequest.getRouteTableId())) {
            internalRequest.addParameter("routeTableId", getRouteRequest.getRouteTableId());
        }
        return this.invokeHttpClient(internalRequest, GetRouteResponse.class);

    }
313887
private DeleteVpcResponseType deleteVpc(final String vpcId) {

        DeleteVpcResponseType ret = new DeleteVpcResponseType();
        ret.setRequestId(UUID.randomUUID().toString());
        mockVpcController.deleteVpc(vpcId);
        return ret;
    }
814280
private void deleteTable(String datasetId, String tableId)
      throws IOException, InterruptedException {
    executeWithBackOff(
        client.tables().delete(projectId, datasetId, tableId),
        String.format(
            "Error when trying to delete the temporary table %s in dataset %s of project %s. "
            + "Manual deletion may be required.",
            tableId, datasetId, projectId));
  }
863419
public ApiResponse<RuleEnvelope> deleteRuleWithHttpInfo(String ruleId) throws ApiException {
        com.squareup.okhttp.Call call = deleteRuleValidateBeforeCall(ruleId, null, null);
        Type localVarReturnType = new TypeToken<RuleEnvelope>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
39763
public Observable<ServiceResponse<Page<DeletedVaultInner>>> listDeletedSinglePageAsync() {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        if (this.client.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiVersion() is required and cannot be null.");
        }
        return service.listDeleted(this.client.subscriptionId(), this.client.apiVersion(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Page<DeletedVaultInner>>>>() {
                @Override
                public Observable<ServiceResponse<Page<DeletedVaultInner>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PageImpl<DeletedVaultInner>> result = listDeletedDelegate(response);
                        return Observable.just(new ServiceResponse<Page<DeletedVaultInner>>(result.body(), result.response()));
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
730835
public MockRouteTable createRouteTable(
            final String cidrBlock, final String vpcId) {

        MockRouteTable ret = new MockRouteTable();
        ret.setRouteTableId(
                "rtb-" + UUID.randomUUID().toString().substring(0, ROUTETABLE_ID_POSTFIX_LENGTH));
        ret.setVpcId(vpcId);
        MockRoute mockRoute = new MockRoute();
        mockRoute.setGatewayId("local");
        mockRoute.setDestinationCidrBlock(cidrBlock);
        mockRoute.setState("active");
        mockRoute.setOrigin("CreateRouteTable");
        List<MockRoute> routeSet = new ArrayList<MockRoute>();
        routeSet.add(mockRoute);
        ret.setRouteSet(routeSet);

        allMockRouteTables.put(ret.getRouteTableId(), ret);
        return ret;
    }
503711
public java.util.List<RouteTable> getRouteTables() {
        if (routeTables == null) {
            routeTables = new com.amazonaws.internal.SdkInternalList<RouteTable>();
        }
        return routeTables;
    }
1133939
public static Route DELETE(String uriPattern, RouteHandler routeHandler) {
        return new Route(HttpConstants.Method.DELETE, uriPattern, routeHandler);
    }
39977
public void setRouteTables(java.util.Collection<RouteTable> routeTables) {
        if (routeTables == null) {
            this.routeTables = null;
            return;
        }

        this.routeTables = new com.amazonaws.internal.SdkInternalList<RouteTable>(routeTables);
    }
468240
public void sendDeleteRequest(String id) {
		OutputStreamWriter writer = null;
		try {
			String deleteRequest = "CMD=Delete&RID=" + id;
			URLConnection serviceConnection = setQBlastServiceProperties(serviceUrl.openConnection());
			writer = new OutputStreamWriter(serviceConnection.getOutputStream());
			writer.write(deleteRequest);
			writer.flush();
		} catch (IOException ignore) {
			// ignore it this is an optional operation
		} finally {
			IOUtils.close(writer);
		}
	}
232048
@SuppressWarnings("unchecked")
	@Override
	public <E> SqlEntityDelete<E> delete(final Class<? extends E> entityType) {
		@SuppressWarnings("rawtypes")
		EntityHandler handler = this.getEntityHandler();
		if (!handler.getEntityType().isAssignableFrom(entityType)) {
			throw new IllegalArgumentException("Entity type not supported");
		}

		try {
			TableMetadata metadata = handler.getMetadata(this.transactionManager, entityType);

			SqlContext context = handler.createDeleteContext(this, metadata, entityType, false);
			context.setSqlKind(SqlKind.DELETE);

			return new SqlEntityDeleteImpl<>(this, handler, metadata, context);
		} catch (SQLException e) {
			throw new EntitySqlRuntimeException(SqlKind.DELETE, e);
		}
	}
1094623
public Optional<RoutingTable> getRoutingTable(final String dataSourceName, final String actualTableName) {
        for (TableUnit each : tableUnits) {
            Optional<RoutingTable> result = each.getRoutingTable(dataSourceName, actualTableName);
            if (result.isPresent()) {
                return result;
            }
        }
        return Optional.absent();
    }
44218
public static base_responses delete(nitro_service client, route resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			route deleteresources[] = new route[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new route();
				deleteresources[i].network = resources[i].network;
				deleteresources[i].netmask = resources[i].netmask;
				deleteresources[i].gateway = resources[i].gateway;
				deleteresources[i].td = resources[i].td;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}