Create a FunctionUpdater to execute update.

@param pathServiceSid The service_sid
@param pathSid The sid
@param friendlyName The friendly_name
@return FunctionUpdater capable of executing the update
772733
public static FunctionUpdater updater(final String pathServiceSid, 
                                          final String pathSid, 
                                          final String friendlyName) {
        return new FunctionUpdater(pathServiceSid, pathSid, friendlyName);
    }
410291
public static SyncMapItemUpdater updater(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemUpdater(pathServiceSid, pathMapSid, pathKey);
    }
1110746
public static <Param> PathParamSerializer<Param> required(String name, Function<String, Param> deserialize,
                                                              Function<Param, String> serialize) {
        return new NamedPathParamSerializer<Param>(name) {
            @Override
            public PSequence<String> serialize(Param parameter) {
                return TreePVector.singleton(serialize.apply(parameter));
            }

            @Override
            public Param deserialize(PSequence<String> parameters) {
                if (parameters.isEmpty()) {
                    throw new IllegalArgumentException(name + " parameter is required");
                } else {
                    return deserialize.apply(parameters.get(0));
                }
            }
        };
    }
877522
public <T extends DataSource> FutureData<ManagedSource> update(String name, T source, ManagedSource id) {
        return update(name, source, id, false);
    }
1091626
public static VariableFetcher fetcher(final String pathServiceSid, 
                                          final String pathEnvironmentSid, 
                                          final String pathSid) {
        return new VariableFetcher(pathServiceSid, pathEnvironmentSid, pathSid);
    }
835622
public static base_response update(nitro_service client, vpathparam resource) throws Exception {
		vpathparam updateresource = new vpathparam();
		updateresource.srcip = resource.srcip;
		return updateresource.update_resource(client);
	}
61129
public<T> Future<Void> update(String pathinfo) throws APIException, CadiException {
		final int idx = pathinfo.indexOf('?');
		final String qp; 
		if(idx>=0) {
			qp=pathinfo.substring(idx+1);
			pathinfo=pathinfo.substring(0,idx);
		} else {
			qp=queryParams;
		}

		EClient<CT> client = client();
		client.setMethod(PUT);
		client.addHeader(CONTENT_TYPE, typeString(Void.class));
		client.setQueryParams(qp);
		client.setFragment(fragment);
		client.setPathInfo(pathinfo);
//		client.setPayload(new EClient.Transfer() {
//			@Override
//			public void transfer(OutputStream os) throws IOException, APIException {
//			}
//		});
		client.send();
		queryParams = fragment = null;
		return client.future(null);
	}
28647
public static SdkUpdater newUpdater(OsInfo.Name osName, Path gcloudPath) {
    switch (osName) {
      case WINDOWS:
        return new SdkUpdater(
            gcloudPath,
            CommandRunner.newRunner(),
            new WindowsBundledPythonCopier(gcloudPath, CommandCaller.newCaller()));
      default:
        return new SdkUpdater(gcloudPath, CommandRunner.newRunner(), null);
    }
  }
969589
public ServiceCall<Collection> updateCollection(UpdateCollectionOptions updateCollectionOptions) {
    Validator.notNull(updateCollectionOptions, "updateCollectionOptions cannot be null");
    String[] pathSegments = { "v1/environments", "collections" };
    String[] pathParameters = { updateCollectionOptions.environmentId(), updateCollectionOptions.collectionId() };
    RequestBuilder builder = RequestBuilder.put(RequestBuilder.constructHttpUrl(getEndPoint(), pathSegments,
        pathParameters));
    builder.query("version", versionDate);
    Map<String, String> sdkHeaders = SdkCommon.getSdkHeaders("discovery", "v1", "updateCollection");
    for (Entry<String, String> header : sdkHeaders.entrySet()) {
      builder.header(header.getKey(), header.getValue());
    }
    builder.header("Accept", "application/json");
    final JsonObject contentJson = new JsonObject();
    if (updateCollectionOptions.name() != null) {
      contentJson.addProperty("name", updateCollectionOptions.name());
    }
    if (updateCollectionOptions.description() != null) {
      contentJson.addProperty("description", updateCollectionOptions.description());
    }
    if (updateCollectionOptions.configurationId() != null) {
      contentJson.addProperty("configuration_id", updateCollectionOptions.configurationId());
    }
    builder.bodyJson(contentJson);
    return createServiceCall(builder.build(), ResponseConverterUtils.getObject(Collection.class));
  }
1272740
public B annotatedService(String pathPrefix, Object service,
                              Iterable<?> exceptionHandlersAndConverters) {
        return annotatedService(pathPrefix, service, Function.identity(),
                                requireNonNull(exceptionHandlersAndConverters,
                                               "exceptionHandlersAndConverters"));
    }
304045
public static StepFetcher fetcher(final String pathFlowSid, 
                                      final String pathEngagementSid, 
                                      final String pathSid) {
        return new StepFetcher(pathFlowSid, pathEngagementSid, pathSid);
    }
994195
public void setName(int pathId, String pathName) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + Constants.PATH_PROFILE_PATHNAME + " = ?" +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, pathName);
            statement.setInt(2, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
356718
public ServerBuilder annotatedService(String pathPrefix, Object service,
                                          Iterable<?> exceptionHandlersAndConverters) {
        return annotatedService(pathPrefix, service, Function.identity(), exceptionHandlersAndConverters);
    }
122397
public ServerBuilder annotatedService(String pathPrefix, Object service) {
        return annotatedService(pathPrefix, service, Function.identity(), ImmutableList.of());
    }
893488
public void updateClientId(String clientId) {
        if (configForVM != null) {
            configForVM.withClientId(clientId);
        } else {
            configForAppService.withClientId(clientId);
        }
    }
268522
public static FunctionVersionCreator creator(final String pathServiceSid, 
                                                 final String pathFunctionSid, 
                                                 final String path, 
                                                 final FunctionVersion.Visibility visibility) {
        return new FunctionVersionCreator(pathServiceSid, pathFunctionSid, path, visibility);
    }
977521
public void updatePathOrder(int profileId, int[] pathOrder) {
        for (int i = 0; i < pathOrder.length; i++) {
            EditService.updatePathTable(Constants.PATH_PROFILE_PATH_ORDER, (i + 1), pathOrder[i]);
        }
    }