Requests that a document be no longer be synchronized by the given _id. Any uncommitted writes
will be lost.

@param nsConfig    the namespace synchronization config of the namespace where the document
lives.
@param documentIds the _ids of the documents.
541810
@CheckReturnValue
  LocalSyncWriteModelContainer desyncDocumentsFromRemote(
      final NamespaceSynchronizationConfig nsConfig,
      final BsonValue... documentIds) {
    this.waitUntilInitialized();
    final MongoNamespace namespace = nsConfig.getNamespace();
    final Lock lock = this.syncConfig.getNamespaceConfig(namespace).getLock().writeLock();
    lock.lock();
    final DeleteManyModel<CoreDocumentSynchronizationConfig> configsToDelete;
    try {
      ongoingOperationsGroup.enter();
      configsToDelete = syncConfig.removeSynchronizedDocuments(namespace, documentIds);
    } finally {
      lock.unlock();
      ongoingOperationsGroup.exit();
    }

    LocalSyncWriteModelContainer container = null;
    if (configsToDelete != null) {
      container = newWriteModelContainer(nsConfig);
      container.addDocIDs(documentIds);
      container.addLocalWrite(new DeleteManyModel<>(
          new BsonDocument("_id",
              new BsonDocument("$in", new BsonArray(Arrays.asList(documentIds))))
      ));
      container.addConfigWrite(configsToDelete);
    }

    return container;
  }
1079257
public void setHostIds(java.util.Collection<String> hostIds) {
        if (hostIds == null) {
            this.hostIds = null;
            return;
        }

        this.hostIds = new com.amazonaws.internal.SdkInternalList<String>(hostIds);
    }
252456
public void setFindingIds(java.util.Collection<String> findingIds) {
        if (findingIds == null) {
            this.findingIds = null;
            return;
        }

        this.findingIds = new java.util.ArrayList<String>(findingIds);
    }
1282838
void recover() {
    final List<NamespaceSynchronizationConfig> nsConfigs = new ArrayList<>();
    for (final MongoNamespace ns : this.syncConfig.getSynchronizedNamespaces()) {
      nsConfigs.add(this.syncConfig.getNamespaceConfig(ns));
    }

    for (final NamespaceSynchronizationConfig nsConfig : nsConfigs) {
      nsConfig.getLock().writeLock().lock();
    }
    try {
      for (final NamespaceSynchronizationConfig nsConfig : nsConfigs) {
        nsConfig.getLock().writeLock().lock();
        try {
          recoverNamespace(nsConfig);
        } finally {
          nsConfig.getLock().writeLock().unlock();
        }
      }
    } finally {
      for (final NamespaceSynchronizationConfig nsConfig : nsConfigs) {
        nsConfig.getLock().writeLock().unlock();
      }
    }
  }
57768
public void sendBlocksBeingWrittenReport(DatanodeProtocol node,
      int namespaceId, DatanodeRegistration nsRegistration) throws IOException {
    Block[] blocks = data.getBlocksBeingWrittenReport(namespaceId);
    if (blocks != null && blocks.length != 0) {
      long[] blocksAsLong =
        BlockListAsLongs.convertToArrayLongs(blocks);
      BlockReport bbwReport = new BlockReport(blocksAsLong);
      node.blocksBeingWrittenReport(nsRegistration, bbwReport);
    }
  }
843527
public void add(String events, String...ids) {
        for (String event : EventDrivenUpdatesMap.parseEvents(events)) {
            Set<String> listenerIds = delegate.get(event);
            if (listenerIds == null) {
                listenerIds = new HashSet<>();
                delegate.put(event, listenerIds);
            }

            listenerIds.addAll(Arrays.asList(ids));
        }        
    }
837748
public void setSharedAwsAccountIds(java.util.Collection<String> sharedAwsAccountIds) {
        if (sharedAwsAccountIds == null) {
            this.sharedAwsAccountIds = null;
            return;
        }

        this.sharedAwsAccountIds = new java.util.ArrayList<String>(sharedAwsAccountIds);
    }
48058
public void setNeighborConfigurationIds(java.util.Collection<String> neighborConfigurationIds) {
        if (neighborConfigurationIds == null) {
            this.neighborConfigurationIds = null;
            return;
        }

        this.neighborConfigurationIds = new java.util.ArrayList<String>(neighborConfigurationIds);
    }
299848
public void clear() {
        documentsByEntity.clear();
        deletedEntities.clear();
        documentsById.clear();
        _knownMissingIds.clear();
        if (_countersByDocId != null) {
            _countersByDocId.clear();
        }
    }
360405
public int deleteIds(DatabaseConnection databaseConnection, Collection<ID> ids, ObjectCache objectCache)
			throws SQLException {
		// have to build this on the fly because the collection has variable number of args
		int result = MappedDeleteCollection.deleteIds(dao, tableInfo, databaseConnection, ids, objectCache);
		if (dao != null && !localIsInBatchMode.get()) {
			dao.notifyChanges();
		}
		return result;
	}
392985
public void document_id_PUT(String id, OvhDocument body) throws IOException {
		String qPath = "/me/document/{id}";
		StringBuilder sb = path(qPath, id);
		exec(qPath, "PUT", sb.toString(), body);
	}
506094
public Set<BsonValue> getPausedDocumentIds(final MongoNamespace namespace) {
    this.waitUntilInitialized();

    try {
      ongoingOperationsGroup.enter();
      final Set<BsonValue> pausedDocumentIds = new HashSet<>();

      for (final CoreDocumentSynchronizationConfig config :
          this.syncConfig.getSynchronizedDocuments(namespace)) {
        if (config.isPaused()) {
          pausedDocumentIds.add(config.getDocumentId());
        }
      }

      return pausedDocumentIds;
    } finally {
      ongoingOperationsGroup.exit();
    }
  }
449639
public void setNetworkInterfaceIds(java.util.Collection<String> networkInterfaceIds) {
        if (networkInterfaceIds == null) {
            this.networkInterfaceIds = null;
            return;
        }

        this.networkInterfaceIds = new com.amazonaws.internal.SdkInternalList<String>(networkInterfaceIds);
    }
666597
public void setDocumentIdentifiers(java.util.Collection<DocumentIdentifier> documentIdentifiers) {
        if (documentIdentifiers == null) {
            this.documentIdentifiers = null;
            return;
        }

        this.documentIdentifiers = new com.amazonaws.internal.SdkInternalList<DocumentIdentifier>(documentIdentifiers);
    }
751263
@Transactional
  public void addMissingMessageIds(String namespace, Set<String> messageIDs) {
    Set<String> alreadyPresent =
        getExistingMessages(namespace, messageIDs)
            .map(L10nString::getMessageID)
            .collect(toCollection(TreeSet::new));
    Set<String> toAdd = Sets.difference(messageIDs, alreadyPresent);
    if (!toAdd.isEmpty()) {
      Stream<L10nString> entities =
          toAdd
              .stream()
              .map(key -> l10nStringFactory.create(key).setMessageID(key))
              .map(l -> l.setNamespace(namespace));
      dataService.add(L10N_STRING, entities);
      LOG.debug("Added message IDs to namespace '{}' : {}.", namespace, messageIDs);
    }
  }
723791
public void remove(String id) {
		final Lock writeLock = lock.writeLock();
		try {
			writeLock.lock();
			final int index = ids.indexOf(id);
			if (index > -1) {
				tasks.remove(index);
				patterns.remove(index);
				ids.remove(index);
				size--;
			}
		} finally {
			writeLock.unlock();
		}
	}
991138
public static base_response clear(nitro_service client, nsconfig resource) throws Exception {
		nsconfig clearresource = new nsconfig();
		clearresource.force = resource.force;
		clearresource.level = resource.level;
		return clearresource.perform_operation(client,"clear");
	}