Use this API to update systemcollectionparam.
495023
public static base_response update(nitro_service client, systemcollectionparam resource) throws Exception {
		systemcollectionparam updateresource = new systemcollectionparam();
		updateresource.communityname = resource.communityname;
		updateresource.loglevel = resource.loglevel;
		updateresource.datapath = resource.datapath;
		return updateresource.update_resource(client);
	}
1210771
private void removeCollectionParameters() {
        int parmCount = SignatureUtils.getNumParameters(getSigConstantOperand());
        if (stack.getStackDepth() >= parmCount) {
            for (int i = 0; i < parmCount; i++) {
                OpcodeStack.Item item = stack.getStackItem(i);
                XField field = item.getXField();
                if (field != null) {
                    collectionFields.remove(field.getName());
                }
            }
        }
    }
150719
@Override
  public void replace(List<ApiType> list, String resourceVersion) {
    lock.lock();
    try {
      Map<String, ApiType> newItems = new HashMap<>();
      for (ApiType item : list) {
        String key = keyFunc.apply(item);
        newItems.put(key, item);
      }
      this.items = newItems;

      // rebuild any index
      this.indices = new HashMap<>();
      for (Map.Entry<String, ApiType> itemEntry : items.entrySet()) {
        this.updateIndices(null, itemEntry.getValue(), itemEntry.getKey());
      }
    } finally {
      lock.unlock();
    }
  }
746723
private void processCollectionStore() {
        String fieldClassName = getDottedClassConstantOperand();
        if (fieldClassName.equals(className) && (stack.getStackDepth() > 0)) {
            OpcodeStack.Item item = stack.getStackItem(0);
            if (item.getUserValue() != null) {
                String fieldName = getNameConstantOperand();
                if (fieldName != null) {
                    FieldInfo fi = collectionFields.get(fieldName);
                    if (fi != null) {
                        fi.getFieldAnnotation().setSourceLines(SourceLineAnnotation.fromVisitedInstruction(this));
                        fi.setSynchronized();
                    }
                }
            }
        }
    }
741347
@Override
  public <T> void updateCollectionSchema(CollectionSchemaUpdate update, String collectionName) {
    CollectionMetaData cmd = cmdMap.get(collectionName);
    @SuppressWarnings("unchecked")
    Map<Object, T> collection = (Map<Object, T>) collectionsRef.get().get(collectionName);
    if((null == cmd) || (null == collection)) {
      throw new InvalidJsonDbApiUsageException("Collection by name '" + collectionName + "' not found. Create collection first.");
    }
    boolean reloadCollectionAsSomethingChanged = false;
    //We only take care of ADD and RENAME, the deletes will be taken care of automatically.
    if (null != update) {
      Map<String, RenameOperation> renOps = update.getRenameOperations();
      if (renOps.size() > 0) {
        reloadCollectionAsSomethingChanged = true;
        cmd.getCollectionLock().writeLock().lock();
        
        for(Entry<String, RenameOperation> updateEntry: renOps.entrySet()) {
          String oldKey = updateEntry.getKey();
          
          RenameOperation op = updateEntry.getValue();
          String newKey = op.getNewName();

          JsonWriter jw;
          try {
            jw = new JsonWriter(dbConfig, cmd, collectionName, fileObjectsRef.get().get(collectionName));
          } catch (IOException ioe) {
            logger.error("Failed to obtain writer for " + collectionName, ioe);
            throw new JsonDBException("Failed to save " + collectionName, ioe);
          }
          jw.renameKeyInJsonFile(collection.values(), true, oldKey, newKey);
        }
        cmd.getCollectionLock().writeLock().unlock();
      }
      
      Map<String, AddOperation> addOps = update.getAddOperations();
      if (addOps.size() > 0) {
        reloadCollectionAsSomethingChanged = true;
        cmd.getCollectionLock().writeLock().lock();
        
        for(Entry<String, AddOperation> updateEntry: addOps.entrySet()) {
          AddOperation op = updateEntry.getValue();
          
          Object value = null;
          if (op.isSecret()) {
            value = dbConfig.getCipher().encrypt((String)op.getDefaultValue());
          } else {
            value = op.getDefaultValue();
          }
          
          String fieldName = updateEntry.getKey();
          Method setterMethod = cmd.getSetterMethodForFieldName(fieldName);
          for(T object : collection.values()) {
            Util.setFieldValueForEntity(object, value, setterMethod);
          }
        }
        
        JsonWriter jw;
        try {
          jw = new JsonWriter(dbConfig, cmd, collectionName, fileObjectsRef.get().get(collectionName));
        } catch (IOException ioe) {
          logger.error("Failed to obtain writer for " + collectionName, ioe);
          throw new JsonDBException("Failed to save " + collectionName, ioe);
        }
        jw.reWriteJsonFile(collection.values(), true);
        cmd.getCollectionLock().writeLock().unlock();
      }
      
      Map<String, DeleteOperation> delOps = update.getDeleteOperations();
      if ((renOps.size() < 1 && addOps.size() < 1) && (delOps.size() > 0)) {
        //There were no ADD operations but there are some DELETE operations so we have to just flush the collection once
        //This would not have been necessary if there was even 1 ADD operation
        
        reloadCollectionAsSomethingChanged = true;
        cmd.getCollectionLock().writeLock().lock();
        
        JsonWriter jw;
        try {
          jw = new JsonWriter(dbConfig, cmd, collectionName, fileObjectsRef.get().get(collectionName));
        } catch (IOException ioe) {
          logger.error("Failed to obtain writer for " + collectionName, ioe);
          throw new JsonDBException("Failed to save " + collectionName, ioe);
        }
        jw.reWriteJsonFile(collection.values(), true);
        cmd.getCollectionLock().writeLock().unlock();
      }
      if (reloadCollectionAsSomethingChanged) {
        reloadCollection(collectionName);
      }
    }
  }
1002864
public static base_response update(nitro_service client, systemgroup resource) throws Exception {
		systemgroup updateresource = new systemgroup();
		updateresource.groupname = resource.groupname;
		updateresource.promptstring = resource.promptstring;
		updateresource.timeout = resource.timeout;
		return updateresource.update_resource(client);
	}
196248
public static ntp_param update(nitro_service client, ntp_param resource) throws Exception
	{
		resource.validate("modify");
		return ((ntp_param[]) resource.update_resource(client))[0];
	}
650618
public void update ()
    {
        // grab the various system properties
        osName = System.getProperty("os.name");
        osVersion = System.getProperty("os.version");
        osArch = System.getProperty("os.arch");
        javaVersion = System.getProperty("java.version");
        javaVendor = System.getProperty("java.vendor");

        // determine memory usage
        Runtime rtime = Runtime.getRuntime();
        freeMemory = rtime.freeMemory() / 1024;
        totalMemory = rtime.totalMemory() / 1024;
        usedMemory = totalMemory - freeMemory;
        maxMemory = rtime.maxMemory() / 1024;

        // determine video display information
        isHeadless = GraphicsEnvironment.isHeadless();
        if (!isHeadless) {
            try {
                GraphicsEnvironment env =
                    GraphicsEnvironment.getLocalGraphicsEnvironment();
                GraphicsDevice gd = env.getDefaultScreenDevice();
                DisplayMode mode = gd.getDisplayMode();
                bitDepth = mode.getBitDepth();
                refreshRate = mode.getRefreshRate() / 1024;
                isFullScreen = (gd.getFullScreenWindow() != null);
                displayWidth = mode.getWidth();
                displayHeight = mode.getHeight();

            } catch (Throwable t) {
                isHeadless = true;
            }
        }
    }
813139
private void updateParams() {
        for (int m = 0; m < documents.length; m++) {
            for (int k = 0; k < K; k++) {
                thetasum[m][k] += (nd[m][k] + alpha) / (ndsum[m] + K * alpha);
            }
        }
        for (int k = 0; k < K; k++) {
            for (int w = 0; w < V; w++) {
                phisum[k][w] += (word_topic_matrix[w][k] + beta) / (nwsum[k] + V * beta);
            }
        }
        numstats++;
    }
1340648
protected void updateParameterTable() {
    parameterTable.setEnabled(false);
    ListParameterization config = new ListParameterization();
    parameterTable.appendParameters(config);
    setParameters(config);
    if(config.getErrors().size() > 0) {
      reportErrors(config);
    }
    config.clearErrors();
    parameterTable.setEnabled(true);
  }
1146947
def set_collection_name(self, value):
        """"""
        old = self.collection
        self.collection = str(value)
        return old
573381
public function update($name, UpdateSettingItemRequest $request, System $systemBundle)
    {
        $this->repository->updateByBundle($systemBundle, $name, $request->input('value'));
        $setting = $systemBundle->getSetting($name);

        return $this->sendResponse($setting, 'Setting item updated successfully.');
    }
596014
def _update(collection_name, upsert, multi, spec, doc, check_keys, opts):
    """"""
    flags = 0
    if upsert:
        flags += 1
    if multi:
        flags += 2
    encode = _dict_to_bson  # Make local. Uses extensions.
    encoded_update = encode(doc, check_keys, opts)
    return b"".join([
        _ZERO_32,
        _make_c_string(collection_name),
        _pack_int(flags),
        encode(spec, False, opts),
        encoded_update]), len(encoded_update)
861087
def update_get_params(self):
        """"""
        if isinstance(self._fields, (tuple, list)):  # tuples & lists > x,y,z
            self.get_params["fields"] = ",".join([str(_) for _ in self._fields])
        elif isinstance(self._fields, str):
            self.get_params["fields"] = self._fields
980309
def update(self, request, *args, **kwargs):
        
        instance = self.get_object()
        if (not request.user.has_perm('edit_collection', instance.collection)
                and not request.user.is_superuser):
            return Response(status=status.HTTP_401_UNAUTHORIZED)

        return super().update(request, *args, **kwargs)
1151818
private void updateExportParams() {

        m_exportParams.setExportAccountData(m_includeAccount.getValue().booleanValue());
        m_exportParams.setExportAsFiles(m_asFiles.getValue().booleanValue());
        m_exportParams.setExportProjectData(m_includeProject.getValue().booleanValue());
        m_exportParams.setExportResourceData(m_includeResource.getValue().booleanValue());
        m_exportParams.setInProject(m_modified.getValue().booleanValue());
        m_exportParams.setIncludeSystemFolder(m_includeSystem.getValue().booleanValue());
        m_exportParams.setIncludeUnchangedResources(m_includeUnchanged.getValue().booleanValue());
        String exportFileName = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
            OpenCms.getSystemInfo().getPackagesRfsPath() + File.separator + (String)m_target.getValue());
        m_exportParams.setPath(exportFileName);
        m_exportParams.setRecursive(m_recursive.getValue().booleanValue());
        m_exportParams.setResources(getResources());
        if (m_changedSince.getValue() != null) {
            m_exportParams.setContentAge(m_changedSince.getDate().getTime());
        } else {
            m_exportParams.setContentAge(0);
        }
    }
822556
public static void updateCollections(PropertyStorage storage, Transport transport) {
        storage.getProperties().forEach(e -> {
            if (Collection.class.isAssignableFrom(e.getKey().getType())) {
                // found a collection in properties
                ((Collection) e.getValue()).forEach(i -> {
                    if (i instanceof FluentStyle) {
                        ((FluentStyle) i).setTransport(transport);
                    }
                });

            }

        });
    }