Will create a bulk delete document based on the specified object.
@param o
@return
775636
public static BulkDeleteDocument of(Object o) {
		return new BulkDeleteDocument(Documents.getId(o), Documents.getRevision(o));
	}
292710
public static Element toElement(Document doc, Object o) throws PageException {
	if (o instanceof Element) return (Element) o;
	else if (o instanceof Node) throw new ExpressionException("Object " + Caster.toClassName(o) + " must be a XML Element");
	return doc.createElement(Caster.toString(o));
    }
333173
public DocumentT findOneAndDelete(final Bson filter) {
    return operations.findOneAndModify(
            "findOneAndDelete",
            filter,
            new BsonDocument(),
            new RemoteFindOneAndModifyOptions(),
            documentClass).execute(service);
  }
1113609
@Override
	public boolean remove(Object o) {
		combine();
		return combined!=null && combined.remove(o);
	}
1265552
@Override
    public void delete(ZooPC obj) {
    	if (obj.getClass() == GenericObject.class) {
    		throw new IllegalArgumentException();
//    		deleteGeneric((GenericObject) obj);
//    		return;
    	}
    	
        if (!isStarted) {
            this.sie = node.getSchemaIE(cls);
            isStarted = true;
        }

        //updated index
        //This is buffered to reduce look-ups to find field indices.
        buffer[bufferCnt++] = obj;
        if (bufferCnt == BUFFER_SIZE) {
            flushBuffer();
        }
    }
675694
public boolean remove(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.remove(o);
        } finally {
            lock.unlock();
        }
    }
749273
@Override
    public boolean clearDocuments() throws DocumentException {

        File internalFolder = new File(this.getDocumentsInternalPath());
        File[] files = internalFolder.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                try {
                    FileUtils.deleteDirectory(file);
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new DocumentException("Unable to delete " + file.getAbsolutePath());
                }
                log.info("Folder deleted: {}", file.getAbsolutePath());
            } else {
                boolean deleted = file.delete();
                if (deleted) {
                    log.info("File deleted: {}", file.getAbsolutePath());
                } else {
                    log.warn("Unable to delete file: {}", file.getAbsolutePath());
                }
            }
        }

        // Clear media types index
        File mapFile = new File(URI.create(new StringBuilder(documentsInternalPath.toString()).append("/" + MEDIA_TYPE_INDEX).toString()));
        if (mapFile.exists()) {
            mapFile.delete();
        }
        fileMediatypeMap.clear();

        // Generate Event
        this.getEventBus().post(new DocumentsClearedEvent(new Date()));

        return true;
    }
833748
public JSONObject deleteObjects(List<String> objects, RequestOptions requestOptions) throws AlgoliaException {
    try {
      JSONArray array = new JSONArray();
      for (String id : objects) {
        JSONObject obj = new JSONObject();
        obj.put("objectID", id);
        JSONObject action = new JSONObject();
        action.put("action", "deleteObject");
        action.put("body", obj);
        array.put(action);
      }
      return batch(array, requestOptions);
    } catch (JSONException e) {
      throw new AlgoliaException(e.getMessage());
    }
  }
101881
public boolean remove(Object o) {
		int index = indexOf(o);
		if (index >= 0) {
			try {
				events.remove(index);
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
			return true;
		} else {
			return false;
		}
	}
959804
public void deleteBulkDocsAsync(String index, String type,
            QueryBuilder filterQueryBuilder,
            ActionListener<BulkResponse> bulkResponseActionListener) {
        executeBulkRequestAsync(
                buildDeleteBulkRequestBuilder(
                        buildExtractDeleteRequestBuilderList(index, type,
                                filterQueryBuilder)),
                bulkResponseActionListener);
    }
576155
public static base_responses delete(nitro_service client, clusterinstance resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			clusterinstance deleteresources[] = new clusterinstance[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new clusterinstance();
				deleteresources[i].clid = resources[i].clid;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
1050120
public IndexCommitBuilder delete(Object object) {
        updateModelClassSet(object);
        getDeleteList(object.getClass()).add((OpenEngSBModel) object);
        return this;
    }
878953
@Override
	public Mono<Void> deleteById(String id) {

		return findSession(id)
				.flatMap(document -> this.mongoOperations.remove(document, this.collectionName).then(Mono.just(document)))
				.map(document -> convertToSession(this.mongoSessionConverter, document))
				.doOnSuccess(mongoSession -> publishEvent(new SessionDeletedEvent(this, mongoSession))) //
				.then();
	}
369776
@Override
    public boolean remove(Object o) {
        if (elements.remove(o)) {
            ordered.remove(o);
            return true;
        } else {
            return false;
        }

    }
56706
@SuppressWarnings("unchecked")
	private Map<String, Object> o(Object obj) {
		return (Map<String, Object>) obj;
	}
208677
public <ResultT> ResultT findOneAndDelete(final Bson filter,
                                            final Class<ResultT> resultClass) {
    return operations.findOneAndModify(
            "findOneAndDelete",
            filter,
            new BsonDocument(),
            new RemoteFindOneAndModifyOptions(),
            resultClass).execute(service);
  }
545280
def bulk_delete(self, query, **kwargs):
        
        response = self._new_response()
        if self._check_supported_op('search', response):
            n = 0
            pe = 'id'
            response = self.search(query, projection_expression=pe, **kwargs)
            while response.status == 'success' and response.data:
                for item in response.data:
                    delete_response = self.delete(item['id'])
                    if response.status != 'success':
                        response = delete_response
                        break
                    n += 1
                response = self.search(
                    query, projection_expression=pe, **kwargs)
            if response.status == 'success':
                response.data = {'deleted': n}
        return response