Update tierConfig parameters
@param TierConfigRequest $tierConfigRequest - TierConfigRequest being updated
@param Param[] $params - array of parameters
@throws GuzzleException
13751
public function updateTierConfigRequestParameters(TierConfigRequest $tierConfigRequest, array $params)
    {
        $body = new TierConfigRequest(['params' => $params]);
        $this->sendRequest('PUT', '/tier/config-requests/' . $tierConfigRequest->id, $body);
    }
403649
function update(req, res, next) {
  var submission = req.body || {};
  submission.submissionId = req.params.id;
  //note this is a work around for submissions which exist in beta before the update to widg guids was done
  if (!submission.appClientId) {
    submission.appClientId = submission.appId;
  }
  var params = {
    submission: submission,
    skipValidation: true
  };

  logger.debug("Middleware Submissions Update ", {params: params});

  forms.updateSubmission(_.extend(req.connectionOptions, params), submissionsHandler(constants.resultTypes.submissions, req, next));
}
269793
public static function updateRequest($request) {
        $routeModel = Dir::apiModel(static::$model);
        $heroe = $routeModel::find($request->id);

        foreach($heroe->getTuples() as $tuple)
            if(!empty($request->$tuple))
                $heroe->$tuple = $request->$tuple;

        $heroe->update();
        return $heroe;
    }
885281
public function handleUpdate(Args $args)
    {
        $name = $args->getArgument('name');
        $descriptorToUpdate = $this->discoveryManager->getRootTypeDescriptor($name);
        $bindingParams = $descriptorToUpdate->getType()->getParameters();
        $description = $descriptorToUpdate->getDescription();
        $paramDescriptions = $descriptorToUpdate->getParameterDescriptions();

        $this->parseParamDescriptions($args, $paramDescriptions);
        $this->parseParams($args, $bindingParams);
        $this->parseUnsetParams($args, $bindingParams, $paramDescriptions);

        if ($args->isOptionSet('description')) {
            $description = $args->getOption('description');
        }

        $updatedDescriptor = new BindingTypeDescriptor(
            new BindingType($name, $bindingParams),
            $description,
            $paramDescriptions
        );

        if ($this->typesEqual($descriptorToUpdate, $updatedDescriptor)) {
            throw new RuntimeException('Nothing to update.');
        }

        $this->discoveryManager->addRootTypeDescriptor($updatedDescriptor, DiscoveryManager::OVERRIDE);

        return 0;
    }
1304105
def set_tier(self, tier):
        ''
        self.tier = tier
        if tier > self.ending_tier:
            self.ending_tier = tier
27146
public synchronized void updateStorageInfo() {
    Map<String, Long> tierCapacities = mBlockWorker.getStoreMeta().getCapacityBytesOnTiers();
    long lastTierReservedBytes = 0;
    for (int ordinal = 0; ordinal < mStorageTierAssoc.size(); ordinal++) {
      String tierAlias = mStorageTierAssoc.getAlias(ordinal);
      long tierCapacity = tierCapacities.get(tierAlias);
      long reservedSpace;
      PropertyKey tierReservedSpaceProp =
          PropertyKey.Template.WORKER_TIERED_STORE_LEVEL_RESERVED_RATIO.format(ordinal);
      if (ServerConfiguration.isSet(tierReservedSpaceProp)) {
        LOG.warn("The property reserved.ratio is deprecated, use high/low watermark instead.");
        reservedSpace = (long) (tierCapacity * ServerConfiguration
            .getDouble(tierReservedSpaceProp));
      } else {
        // High watermark defines when to start the space reserving process
        PropertyKey tierHighWatermarkProp =
            PropertyKey.Template.WORKER_TIERED_STORE_LEVEL_HIGH_WATERMARK_RATIO.format(ordinal);
        double tierHighWatermarkConf = ServerConfiguration.getDouble(tierHighWatermarkProp);
        Preconditions.checkArgument(tierHighWatermarkConf > 0,
            "The high watermark of tier %s should be positive, but is %s",
            Integer.toString(ordinal), tierHighWatermarkConf);
        Preconditions.checkArgument(tierHighWatermarkConf < 1,
            "The high watermark of tier %s should be less than 1.0, but is %s",
            Integer.toString(ordinal), tierHighWatermarkConf);
        long highWatermark = (long) (tierCapacity * ServerConfiguration
            .getDouble(tierHighWatermarkProp));
        mHighWatermarks.put(tierAlias, highWatermark);

        // Low watermark defines when to stop the space reserving process if started
        PropertyKey tierLowWatermarkProp =
            PropertyKey.Template.WORKER_TIERED_STORE_LEVEL_LOW_WATERMARK_RATIO.format(ordinal);
        double tierLowWatermarkConf = ServerConfiguration.getDouble(tierLowWatermarkProp);
        Preconditions.checkArgument(tierLowWatermarkConf >= 0,
            "The low watermark of tier %s should not be negative, but is %s",
            Integer.toString(ordinal), tierLowWatermarkConf);
        Preconditions.checkArgument(tierLowWatermarkConf < tierHighWatermarkConf,
            "The low watermark (%s) of tier %d should not be smaller than the high watermark (%s)",
            tierLowWatermarkConf, ordinal, tierHighWatermarkConf);
        reservedSpace =
            (long) (tierCapacity - tierCapacity * ServerConfiguration
                .getDouble(tierLowWatermarkProp));
      }
      lastTierReservedBytes += reservedSpace;
      // On each tier, we reserve no more than its capacity
      lastTierReservedBytes =
          (lastTierReservedBytes <= tierCapacity) ? lastTierReservedBytes : tierCapacity;
      mReservedSpaces.put(tierAlias, lastTierReservedBytes);
    }
  }
930424
protected function updateParameters()
    {
        $filename = $this->projectDir.'/app/config/parameters.yml';

        if (!is_writable($filename)) {
            if ($this->output->isVerbose()) {
                $this->output->writeln(sprintf(
                    " <comment>[WARNING]</comment> The value of the <info>secret</info> configuration option cannot be updated because\n".
                    " the <comment>%s</comment> file is not writable.\n",
                    $filename
                ));
            }

            return $this;
        }

        $ret = str_replace('ThisTokenIsNotSoSecretChangeIt', $this->generateRandomSecret(), file_get_contents($filename));
        file_put_contents($filename, $ret);

        return $this;
    }
831819
public function update(OrderStatus $orderstatus, UpdateOrderStatusRequest $request)
    {
        $this->orderstatus->update($orderstatus, $request->all());

        return redirect()->route('admin.order.orderstatus.index')
            ->withSuccess(trans('core::core.messages.resource updated', ['name' => trans('order::orderstatuses.title.orderstatuses')]));
    }
282204
private function updateQueryTranslation(Query $query, array $parameterData, string $locale): void
    {
        $updateStruct = $this->collectionService->newQueryUpdateStruct($locale, $query);
        $updateStruct->fillParametersFromHash($query->getQueryType(), $parameterData, true);

        $this->collectionService->updateQuery($query, $updateStruct);
    }
704772
protected function setRequestHeaders(ServerRequestInterface $baseRequest, array $params)
    {
        $headers = (new ServerRequest())->withServerParams($params)->getHeaders();
        $psrRequest = $baseRequest;

        foreach ($headers as $header => $values) {
            $psrRequest = $psrRequest->withHeader($header, $values);
        }
        
        return $psrRequest;
    }
888304
protected function set_params( $params ) {
		$this->requirements_details_url = ! empty( $params['requirements_details_url'] ) ? esc_url( trim( (string) $params['requirements_details_url'] ) ) : $this->requirements_details_url;
		$this->version_compare_operator = ! empty( $params['version_compare_operator'] ) ? (string) $params['version_compare_operator'] : $this->version_compare_operator;
		$this->not_valid_actions        = ! empty( $params['not_valid_actions'] ) ? (array) $params['not_valid_actions'] : $this->not_valid_actions;
		$this->show_valid_results       = isset( $params['show_valid_results'] ) ? (bool) $params['show_valid_results'] : $this->show_valid_results;
	}
894960
public function setQueryParams(array $params)
    {
        $uri = $this->guzzleRequest->getUri()->withQuery(\GuzzleHttp\Psr7\build_query($params));
        $this->guzzleRequest = $this->guzzleRequest->withUri($uri);
    }
639331
public function updateConfig(&$config)
    {
        if (!isset($config['types'])) {
            $config['types'] = [];
        }

        $config['types']['VersionedStage'] = VersionedStage::class;
        $config['types']['VersionedStatus'] = VersionedStatus::class;
        $config['types']['VersionedQueryMode'] = VersionedQueryMode::class;
        $config['types']['VersionedInputType'] = VersionedInputType::class;
        $config['types']['CopyToStageInputType'] = CopyToStageInputType::class;
    }
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.');
    }
243615
public static void updateParameter(final HierarchicalConfiguration config, final String subKey, final String nameKey, final String valueKey,
		final Map<String, String> parameters) {
		for (HierarchicalConfiguration subConfig : config.configurationsAt(subKey)) {
			subConfig.clear();
		}
		String newNameKey = subKey + "(-1)." + nameKey;
		String newValueKey = subKey + '.' + valueKey;
		for (Map.Entry<String, String> parameter : parameters.entrySet()) {
			config.addProperty(newNameKey, parameter.getKey());
			config.addProperty(newValueKey, parameter.getValue());
		}
	}
814214
public void fillParamValues(CmsWorkplaceSettings settings, HttpServletRequest request) {

        initSettings(settings, request);
        fillParamValues(request);
    }
656264
protected function _validateParams(array $params) {
        $config = new Garp_Util_Configuration($params);
        $config->obligate('to');
        $config->obligate('subject');

        if (!isset($params['message']) && !isset($params['htmlMessage'])) {
            throw new Garp_Util_Configuration_Exception(
                sprintf(
                    Garp_Util_Configuration::EXCEPTION_MISSINGKEY,
                    'message OR htmlMessage'
                )
            );
        }
    }