Delete all synonym set

@param forwardToReplicas Forward the operation to the replica indices
@param requestOptions    Options to pass to this request
519176
public JSONObject clearSynonyms(boolean forwardToReplicas, RequestOptions requestOptions) throws AlgoliaException {
    return client.postRequest("/1/indexes/" + encodedIndexName + "/synonyms/clear?forwardToReplicas=" + forwardToReplicas, "", true, false, requestOptions);
  }
564530
@Override
	public com.liferay.commerce.product.model.CPOption deleteCPOption(
		com.liferay.commerce.product.model.CPOption cpOption)
		throws com.liferay.portal.kernel.exception.PortalException {
		return _cpOptionLocalService.deleteCPOption(cpOption);
	}
842105
def forwards(self, orm):
        ""
        for instance in orm.LocationSource.objects.all():
            try:
                instance.user = instance.points.all()[0].user
                instance.save()
            except IndexError:
                # No points for this source.
                instance.delete()
346387
public void clearReplicaSyncRequest(int partitionId, ServiceNamespace namespace, int replicaIndex) {
        ReplicaFragmentSyncInfo syncInfo = new ReplicaFragmentSyncInfo(partitionId, namespace, replicaIndex, null);
        if (!replicaSyncRequests.remove(syncInfo)) {
            return;
        }

        if (logger.isFinestEnabled()) {
            logger.finest("Clearing sync replica request for partitionId=" + partitionId + ", replicaIndex="
                    + replicaIndex + ", namespace=" + namespace);
        }
        releaseReplicaSyncPermits(1);
        replicaSyncTimeoutScheduler.cancelIfExists(syncInfo, null);
    }
1300351
def delete(self, opts):
        """"""

        argv = opts.args
        count = len(argv)

        # unflagged arguments are conf, stanza, key. In this order
        # however, we must have a conf and stanza.
        cpres = True if count > 0 else False
        spres = True if count > 1 else False
        kpres = True if count > 2 else False 
        
        if not cpres:
            error("Conf name is required for delete", 2)

        if not cpres and not spres:
            error("Conf name and stanza name is required for delete", 2)

        if kpres:
            error("Cannot delete individual keys from a stanza", 2)

        name = argv[0]
        stan = argv[1]
        conf = self.service.confs[name]
        conf.delete(stan)
1073758
@Override
	public com.liferay.commerce.shipping.engine.fixed.model.CommerceShippingFixedOption deleteCommerceShippingFixedOption(
		com.liferay.commerce.shipping.engine.fixed.model.CommerceShippingFixedOption commerceShippingFixedOption) {
		return _commerceShippingFixedOptionLocalService.deleteCommerceShippingFixedOption(commerceShippingFixedOption);
	}
1281328
public static base_responses delete(nitro_service client, cacheforwardproxy resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			cacheforwardproxy deleteresources[] = new cacheforwardproxy[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new cacheforwardproxy();
				deleteresources[i].ipaddress = resources[i].ipaddress;
				deleteresources[i].port = resources[i].port;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
612578
public void deleteByKeys(String projectUuid, Collection<String> issueKeys) {
    if (issueKeys.isEmpty()) {
      return;
    }

    BulkIndexer bulkIndexer = createBulkIndexer(Size.REGULAR, IndexingListener.FAIL_ON_ERROR);
    bulkIndexer.start();
    issueKeys.forEach(issueKey -> bulkIndexer.addDeletion(TYPE_ISSUE.getMainType(), issueKey, AuthorizationDoc.idOf(projectUuid)));
    bulkIndexer.stop();
  }
1252859
public static <S> void removeSolutionsFromList(List<S> solutionList, int numberOfSolutionsToRemove) {
    if (solutionList.size() < numberOfSolutionsToRemove) {
      throw new JMetalException("The list size (" + solutionList.size() + ") is lower than " +
          "the number of solutions to remove (" + numberOfSolutionsToRemove + ")");
    }

    for (int i = 0; i < numberOfSolutionsToRemove; i++) {
      solutionList.remove(0);
    }
  }
566981
function remove(req, res, next) {
  var params = {
    appId: req.params.id
  };

  forms.deleteAppReferences(req.connectionOptions, params, formsResultHandlers(constants.resultTypes.formProjects, req, next));
}
842050
@Override
	public void removeByCommerceShippingFixedOptionId(
		long commerceShippingFixedOptionId) {
		for (CommerceShippingFixedOptionRel commerceShippingFixedOptionRel : findByCommerceShippingFixedOptionId(
				commerceShippingFixedOptionId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(commerceShippingFixedOptionRel);
		}
	}
1055471
public JSONObject saveSynonym(String objectID, JSONObject content, boolean forwardToReplicas) throws AlgoliaException {
    return this.saveSynonym(objectID, content, forwardToReplicas, RequestOptions.empty);
  }
1269309
def forward_all(collection)
      newcollection = collection.dup.clear
      collection.each do |point|
        newcollection << forward(point)
      end
      newcollection
    end
457905
public void clearAllTopics()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "clearAllTopics");
    //stop the consumption from this remote topic space
  	_anycastInputHandler.forceFlushAtTarget(); 	 
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "clearAllTopics"); 
  }
1065378
def delete_api_key(key, request_options = {})
      client.delete(Protocol.index_key_uri(name, key), :write, request_options)
    end
1019517
def replace_all_rules(rules, request_options = {})
      forward_to_replicas = request_options[:forwardToReplicas] || request_options['forwardToReplicas'] || false
      batch_rules(rules, forward_to_replicas, true, request_options)
    end
411206
@Delete("/metadata/{projectName}/repos/{repoName}/perm/tokens/{appId}")
    public CompletableFuture<Revision> removeSpecificTokenPermission(@Param("projectName") String projectName,
                                                                     @Param("repoName") String repoName,
                                                                     @Param("appId") String appId,
                                                                     Author author) {
        return mds.findTokenByAppId(appId)
                  .thenCompose(token -> mds.removePerTokenPermission(author,
                                                                     projectName, repoName, appId));
    }