Update the resource in the persistence layer.

@param builder the Trellis response builder
@return a response builder promise
425343
public CompletionStage<ResponseBuilder> updateResource(final ResponseBuilder builder) {
        LOGGER.debug("Updating {} via PATCH", getIdentifier());

        // Add the LDP link types
        if (ACL.equals(getRequest().getExt())) {
            getLinkTypes(LDP.RDFSource).forEach(type -> builder.link(type, "type"));
        } else {
            getLinkTypes(getResource().getInteractionModel()).forEach(type -> builder.link(type, "type"));
        }

        final TrellisDataset mutable = TrellisDataset.createDataset();
        final TrellisDataset immutable = TrellisDataset.createDataset();

        return assembleResponse(mutable, immutable, builder)
            .whenComplete((a, b) -> mutable.close())
            .whenComplete((a, b) -> immutable.close());
    }
778621
public static void putAuthenticationResultBuilder(final AuthenticationResultBuilder builder, final RequestContext ctx) {
        ctx.getConversationScope().put(PARAMETER_AUTHENTICATION_RESULT_BUILDER, builder);
    }
68676
@Override
    public ClosableDataBuilder<MB> getDataBuilder(final Object consumer, final boolean notifyChange) {
        return new ClosableDataBuilder<>(getBuilderSetup(), consumer, notifyChange);
    }
1070369
public static base_responses update(nitro_service client, tmtrafficaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			tmtrafficaction updateresources[] = new tmtrafficaction[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new tmtrafficaction();
				updateresources[i].name = resources[i].name;
				updateresources[i].apptimeout = resources[i].apptimeout;
				updateresources[i].sso = resources[i].sso;
				updateresources[i].formssoaction = resources[i].formssoaction;
				updateresources[i].persistentcookie = resources[i].persistentcookie;
				updateresources[i].initiatelogout = resources[i].initiatelogout;
				updateresources[i].kcdaccount = resources[i].kcdaccount;
				updateresources[i].samlssoprofile = resources[i].samlssoprofile;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
778961
public Datatype.Builder setNullableBuilderFactory(BuilderFactory builderFactory) {
    if (builderFactory != null) {
      return setBuilderFactory(builderFactory);
    } else {
      return clearBuilderFactory();
    }
  }
44649
def build(self, builder):
        
        builder.start("ReasonForChange", {})
        builder.data(self.reason)
        builder.end("ReasonForChange")
435794
public <T extends AbstractGoogleJsonClient.Builder> T fromApiKey(T builder, String apiKey) {
    Preconditions.checkNotNull(builder);
    Preconditions.checkNotNull(apiKey);
    return prepareBuilder(builder, null, new CommonGoogleClientRequestInitializer(apiKey));
  }
477405
public <T extends Message> ObjectOrStatus<T> delete(T.Builder builder, String path)
      throws ApiException, IOException {
    return request(builder, path, "DELETE", null, null, null);
  }
569456
protected function addKeep(Builder $builder): void
    {
        $builder->macro('keep', function (Builder $builder) {
            $builder->withNotKept();

            return $builder->update(['is_kept' => 1]);
        });
    }
272492
def build(self, builder):
        
        builder.start("LocationRef", dict(LocationOID=str(self.oid)))
        builder.end("LocationRef")
19243
public function setBuilder(IlluminateEloquentBuilder $builder = null)
    {
        // If no builder was provided,
        // we'll use the one from this repositorys model
        if (empty($builder)) {
            $builder = $this->getModel()->newQuery();
        }

        // Set repository builder
        $this->builder = $builder;

        return $this;
    }
715453
function(lender) {
                console.log('borrowInterface.lender.update');

                return this.request({
                    url: this._buildUri(this.uri, this.id),
                    method: corbel.request.method.PUT,
                    data: lender
                });
            }
984430
public BulkRequestBuilder buildUpdateBulkRequestBuilder(
            List<UpdateRequestBuilder> updateRequestBuilderList) {
        BulkRequestBuilder bulkRequestBuilder = jmESClient.prepareBulk();
        for (UpdateRequestBuilder updateRequestBuilder : updateRequestBuilderList)
            bulkRequestBuilder.add(updateRequestBuilder);
        return bulkRequestBuilder;
    }
1211366
public static DesiredCapabilities retrieveCustomCapabilities(Class<? extends DefaultCapabilitiesBuilder> builder) {
        logger.entering(builder);

        DesiredCapabilities caps = new DesiredCapabilities();
        if (builder != null && !builder.getName().equals(DefaultCapabilitiesBuilder.class.getName())) {
            try {
                caps = builder.newInstance().createCapabilities();
            } catch (InstantiationException | IllegalAccessException e) {
                throw new IllegalStateException("Unable to apply desired capabilities from " + builder.getName(), e);
            }
        }

        logger.exiting(caps);
        return caps;
    }
561294
@Override
  @SuppressWarnings("unchecked")
  public UserManagedCacheBuilder<K, V, PersistentUserManagedCache<K, V>> builder(UserManagedCacheBuilder<K, V, ? extends UserManagedCache<K, V>> builder) {
    return (UserManagedCacheBuilder<K, V, PersistentUserManagedCache<K, V>>) builder.identifier(identifier).using(persistenceService);
  }
1347346
def build(self, builder):
        
        params = {}

        if self.value is not None:
            params['Value'] = str(self.value)

        if self.query_repeat_key is not None:
            params['QueryRepeatKey'] = str(self.query_repeat_key)

        if self.recipient is not None:
            params['Recipient'] = str(self.recipient)

        if self.status is not None:
            params['Status'] = self.status.value

        if self.requires_response is not None:
            params['RequiresResponse'] = bool_to_yes_no(self.requires_response)

        # When closing a query
        if self.response is not None:
            params['Response'] = str(self.response)

        builder.start("mdsol:Query", params)
        builder.end("mdsol:Query")
449212
public static base_response update(nitro_service client, responderparam resource) throws Exception {
		responderparam updateresource = new responderparam();
		updateresource.undefaction = resource.undefaction;
		return updateresource.update_resource(client);
	}