This method is used to set ppp aaa
@param type $use_radius string
@param type $accounting string
@param type $interim_update string
@return type array
329742
public function set($use_radius, $accounting, $interim_update) {
        $sentence = new SentenceUtil();
        $sentence->addCommand("/ppp/aaa/set");
        $sentence->setAttribute("use-radius", $use_radius);
        $sentence->setAttribute("accounting", $accounting);
        $sentence->setAttribute("interim-update", $interim_update);
        $this->talker->send($sentence);
        return "Sucsess";
    }
1182166
public function useAssetsPreset($preset_name = null)
    {
        $preset = $this->assets_loader->getPreset($preset_name);
        $preset->load();
    }
832891
public void updateServiceInstance(ProvidedServiceInstance instance, final RegistrationCallback cb, Object context){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UpdateServiceInstance);

        UpdateServiceInstanceProtocol p = new UpdateServiceInstanceProtocol(instance);
        ProtocolCallback pcb = new ProtocolCallback(){

            @Override
            public void call(boolean result, Response response,
                    ErrorCode error, Object ctx) {
                cb.call(result, error, ctx);
            }

        };
        connection.submitCallbackRequest(header, p, pcb, context);
    }
244262
public static function update(
        int $bunqmeFundraiserResultId,
        int $noteTextBunqMeFundraiserResultId,
        int $monetaryAccountId = null,
        string $content = null,
        array $customHeaders = []
    ): BunqResponseInt {
        $apiClient = new ApiClient(static::getApiContext());
        $responseRaw = $apiClient->put(
            vsprintf(
                self::ENDPOINT_URL_UPDATE,
                [
                    static::determineUserId(),
                    static::determineMonetaryAccountId($monetaryAccountId),
                    $bunqmeFundraiserResultId,
                    $noteTextBunqMeFundraiserResultId,
                ]
            ),
            [self::FIELD_CONTENT => $content],
            $customHeaders
        );

        return BunqResponseInt::castFromBunqResponse(
            static::processForId($responseRaw)
        );
    }
138423
public function update_preapproval_payment($id, $preapproval_payment) {
        $request = array(
            "uri" => "/preapproval/{$id}",
            "params" => array(
                "access_token" => $this->get_access_token()
            ),
            "data" => $preapproval_payment
        );

        $preapproval_payment_result = MPRestClient::put($request);
        return $preapproval_payment_result;
    }
1033077
public function setUseHTTPS(string $use_https = "F") : CNabuDataObject
    {
        if ($use_https === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$use_https")
            );
        }
        $this->setValue('nb_site_target_use_https', $use_https);
        
        return $this;
    }
1031484
def before_update(self, context, current, resource):
        

        # Return if the budget data package fields have not been filled in
        if not self.are_budget_data_package_fields_filled_in(resource):
            return

        if resource.get('upload', '') == '':
            # If it isn't an upload we check if it's the same url
            if current['url'] == resource['url']:
                # Return if it's the same
                return
            else:
                self.data.load(resource['url'])
        else:
            self.data.load(resource['upload'].file)

        self.generate_budget_data_package(resource)
689587
public static base_response update(nitro_service client, aaakcdaccount resource) throws Exception {
		aaakcdaccount updateresource = new aaakcdaccount();
		updateresource.kcdaccount = resource.kcdaccount;
		updateresource.keytab = resource.keytab;
		updateresource.realmstr = resource.realmstr;
		updateresource.delegateduser = resource.delegateduser;
		updateresource.kcdpassword = resource.kcdpassword;
		updateresource.usercert = resource.usercert;
		updateresource.cacert = resource.cacert;
		return updateresource.update_resource(client);
	}
743905
public function createOperation(
        $amount,
        $originAmount,
        DateTime $cycleDate,
        $paymentVoucher,
        $vendor,
        $adjustedOperationsIds = null
    ) {
        //Set hipay id
        $hipayId = $vendor->getHiPayId();

        //Call implementation function
        $operation = $this->operationManager->create($amount, $cycleDate, $paymentVoucher, $vendor->getMiraklId());

        $operation->setHiPayId($hipayId);

        //Sets mandatory values
        $operation->setMiraklId($vendor->getMiraklId());
        $operation->setStatus(new Status(Status::CREATED));
        $operation->setUpdatedAt(new DateTime());
        $operation->setAmount($amount);
        $operation->setOriginAmount($originAmount);
        $operation->setCycleDate($cycleDate);
        $operation->setPaymentVoucher((string)$paymentVoucher);

        // if adjustments were made, save adjusted operations
        if ($adjustedOperationsIds !== null) {
            $operation->setAdjustmentIds(json_encode($adjustedOperationsIds));
        }

        $this->isOperationValid($operation);

        $this->operationsLogs[] = $this->logOperationsManager->create(
            $vendor->getMiraklId(),
            $hipayId,
            (string)$paymentVoucher,
            $amount,
            $originAmount,
            $this->hipay->getBalance($vendor)
        );
        return $operation;
    }
1308042
private boolean usePendingAcquisition(SessionProtocol desiredProtocol, PoolKey key,
                                          CompletableFuture<PooledChannel> promise,
                                          ClientConnectionTimingsBuilder timingsBuilder) {

        if (desiredProtocol == SessionProtocol.H1 || desiredProtocol == SessionProtocol.H1C) {
            // Can't use HTTP/1 connections because they will not be available in the pool until
            // the request is done.
            return false;
        }

        final CompletableFuture<PooledChannel> pendingAcquisition =
                getPendingAcquisition(desiredProtocol, key);

        if (pendingAcquisition == null) {
            return false;
        }

        timingsBuilder.pendingAcquisitionStart();
        pendingAcquisition.handle((pch, cause) -> {
            timingsBuilder.pendingAcquisitionEnd();

            if (cause == null) {
                final SessionProtocol actualProtocol = pch.protocol();
                if (actualProtocol.isMultiplex()) {
                    promise.complete(pch);
                } else {
                    // Try to acquire again because the connection was not HTTP/2.
                    // We use the exact protocol (H1 or H1C) instead of 'desiredProtocol' so that
                    // we do not waste our time looking for pending acquisitions for the host
                    // that does not support HTTP/2.
                    final PooledChannel ch = acquireNow(actualProtocol, key);
                    if (ch != null) {
                        promise.complete(ch);
                    } else {
                        connect(actualProtocol, key, promise, timingsBuilder);
                    }
                }
            } else {
                // The pending connection attempt has failed.
                connect(desiredProtocol, key, promise, timingsBuilder);
            }
            return null;
        });

        return true;
    }
330356
public void setObjectAcl(String bucketName, String key, String versionId,
            AccessControlList acl, RequestMetricCollector requestMetricCollector)
            throws SdkClientException, AmazonServiceException {
        setObjectAcl(new SetObjectAclRequest(bucketName, key, versionId, acl)
                .<SetObjectAclRequest> withRequestMetricCollector(requestMetricCollector));
    }
419516
def updateSolutionTerminal(self):
        '''
        
        '''
        self.solution_terminal.vFunc = ValueFunc2D(self.cFunc_terminal_,self.CRRA)
        self.solution_terminal.vPfunc = MargValueFunc2D(self.cFunc_terminal_,self.CRRA)
        self.solution_terminal.vPPfunc = MargMargValueFunc2D(self.cFunc_terminal_,self.CRRA)
        self.solution_terminal.hNrm = 0.0 # Don't track normalized human wealth
        self.solution_terminal.hLvl = lambda p : np.zeros_like(p) # But do track absolute human wealth by persistent income
        self.solution_terminal.mLvlMin = lambda p : np.zeros_like(p)
1153039
public function setUseURI(string $use_uri = "N") : CNabuDataObject
    {
        if ($use_uri === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$use_uri")
            );
        }
        $this->setValue('nb_site_map_use_uri', $use_uri);
        
        return $this;
    }
665919
public static base_response update(nitro_service client, aaaparameter resource) throws Exception {
		aaaparameter updateresource = new aaaparameter();
		updateresource.enablestaticpagecaching = resource.enablestaticpagecaching;
		updateresource.enableenhancedauthfeedback = resource.enableenhancedauthfeedback;
		updateresource.defaultauthtype = resource.defaultauthtype;
		updateresource.maxaaausers = resource.maxaaausers;
		updateresource.maxloginattempts = resource.maxloginattempts;
		updateresource.failedlogintimeout = resource.failedlogintimeout;
		updateresource.aaadnatip = resource.aaadnatip;
		return updateresource.update_resource(client);
	}
706361
public function setMethodUsed( string $api_key, string $region, string $endpoint, int $timeInterval, int $value )
	{
		$this->limits[$region][$api_key]['method'][$endpoint][$timeInterval]['used'] = $value;
		if ($value == 1)
			$this->limits[$region][$api_key]['method'][$endpoint][$timeInterval]['expires'] = time() + $timeInterval;
	}
1032683
function AAP( buffer, start, end ) {

  if( !(this instanceof AAP) )
    return new AAP( buffer, start, end )

  /** @type {MBR.AAP.Record} AAP Record */
  this.aap = new AAP.Record()

  MBR.call( this, buffer, start, end )

}
922152
function propagateFinalBad(arrFinalBadUnits, onPropagated){
		if (arrFinalBadUnits.length === 0)
			return onPropagated();
		conn.query("SELECT DISTINCT unit FROM inputs WHERE src_unit IN(?)", [arrFinalBadUnits], function(rows){
			if (rows.length === 0)
				return onPropagated();
			var arrSpendingUnits = rows.map(function(row){ return row.unit; });
			conn.query("UPDATE units SET sequence='final-bad' WHERE unit IN(?)", [arrSpendingUnits], function(){
				arrSpendingUnits.forEach(function(unit){
					storage.assocUnstableUnits[unit].sequence = 'final-bad';
				});
				propagateFinalBad(arrSpendingUnits, onPropagated);
			});
		});
	}