<pre>
Use this operation to modify MPS network configuration.
</pre>
763436
public static mps_network_config update(nitro_service client, mps_network_config resource) throws Exception
	{
		resource.validate("modify");
		return ((mps_network_config[]) resource.update_resource(client))[0];
	}
726285
@SuppressLint("MissingPermission")
  void putNetwork(Context context) {
    Map<String, Object> network = createMap();
    if (hasPermission(context, ACCESS_NETWORK_STATE)) {
      ConnectivityManager connectivityManager = getSystemService(context, CONNECTIVITY_SERVICE);
      if (connectivityManager != null) {
        NetworkInfo wifiInfo = connectivityManager.getNetworkInfo(TYPE_WIFI);
        network.put(NETWORK_WIFI_KEY, wifiInfo != null && wifiInfo.isConnected());
        NetworkInfo bluetoothInfo = connectivityManager.getNetworkInfo(TYPE_BLUETOOTH);
        network.put(NETWORK_BLUETOOTH_KEY, bluetoothInfo != null && bluetoothInfo.isConnected());
        NetworkInfo cellularInfo = connectivityManager.getNetworkInfo(TYPE_MOBILE);
        network.put(NETWORK_CELLULAR_KEY, cellularInfo != null && cellularInfo.isConnected());
      }
    }

    TelephonyManager telephonyManager = getSystemService(context, TELEPHONY_SERVICE);
    if (telephonyManager != null) {
      network.put(NETWORK_CARRIER_KEY, telephonyManager.getNetworkOperatorName());
    } else {
      network.put(NETWORK_CARRIER_KEY, "unknown");
    }

    put(NETWORK_KEY, network);
  }
841165
private static void changeNetworkWPA(WifiManager wifiManager, WifiParsedResult wifiResult) {
    WifiConfiguration config = changeNetworkCommon(wifiResult);
    // Hex passwords that are 64 bits long are not to be quoted.
    config.preSharedKey = quoteNonHex(wifiResult.getPassword(), 64);
    config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
    config.allowedProtocols.set(WifiConfiguration.Protocol.WPA); // For WPA
    config.allowedProtocols.set(WifiConfiguration.Protocol.RSN); // For WPA2
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    updateNetwork(wifiManager, config);
  }
238510
public static current_hostname modify(nitro_service client, current_hostname resource) throws Exception
	{
		resource.validate("modify");
		return ((current_hostname[]) resource.update_resource(client))[0];
	}
17953
public void modifiedService(ServiceReference<WebApplicationFactory<?>> reference,
            WebApplicationFactory<?> service) {
        removeApplication(reference);
        PaxWicketApplicationFactory internalFactory =
            PaxWicketApplicationFactory.createPaxWicketApplicationFactory(context, service,
                reference);
        addApplication(reference, internalFactory);
    }
284125
def alter(self, operation, timeout=None, metadata=None, credentials=None):
        """"""
        return self.stub.Alter(operation, timeout=timeout, metadata=metadata,
                               credentials=credentials)
373079
@Process(actionType = ModifyProviderConfiguration.class)
    public void modifyProviderConfiguration(final ModifyProviderConfiguration action, final Dispatcher.Channel channel) {
        operationDelegate.onSaveResource(WS_SUBSYSTEM, null, action.getChangedValues(),
                new CrudOperationDelegate.Callback() {
                    @Override
                    public void onSuccess(final AddressTemplate addressTemplate, final String name) {
                        final ModelNode op = readProviderConfiguration();
                        dispatcher.execute(new DMRAction(op), new AsyncCallback<DMRResponse>() {
                            @Override
                            public void onFailure(Throwable caught) {
                                channel.nack(caught);
                            }

                            @Override
                            public void onSuccess(DMRResponse dmrResponse) {
                                ModelNode response = dmrResponse.get();
                                if (response.isFailure()) {
                                    channel.nack(new RuntimeException("Failed to read " + addressTemplate + " using " + op + ": " +
                                            response.getFailureDescription()));
                                } else {
                                    providerConfiguration = response.get(RESULT);
                                    channel.ack();
                                }
                            }
                        });
                    }

                    @Override
                    public void onFailure(AddressTemplate addressTemplate, String name, Throwable t) {
                        channel.nack(t);
                    }
                });
    }
277232
public Operation addAccessConfig(
      String networkInterface, AccessConfig accessConfig, OperationOption... options) {
    return compute.addAccessConfig(getInstanceId(), networkInterface, accessConfig, options);
  }
1260733
@Process(actionType = ModifyEndpointConfiguration.class)
    public void modifyEndpointConfiguration(final ModifyEndpointConfiguration action, final Dispatcher.Channel channel) {
        operationDelegate.onSaveResource(ENDPOINT_CONFIGURATION_ADDRESS, null, action.getChangedValues(),
                new CrudOperationDelegate.Callback() {
                    @Override
                    public void onSuccess(final AddressTemplate addressTemplate, final String name) {
                        final ModelNode op = readEndpointConfiguration();
                        dispatcher.execute(new DMRAction(op), new AsyncCallback<DMRResponse>() {
                            @Override
                            public void onFailure(Throwable caught) {
                                channel.nack(caught);
                            }

                            @Override
                            public void onSuccess(DMRResponse dmrResponse) {
                                ModelNode response = dmrResponse.get();
                                if (response.isFailure()) {
                                    channel.nack(new RuntimeException("Failed to read " + addressTemplate + " using " + op + ": " +
                                            response.getFailureDescription()));
                                } else {
                                    endpointConfiguration = response.get(RESULT);
                                    channel.ack();
                                }
                            }
                        });
                    }

                    @Override
                    public void onFailure(AddressTemplate addressTemplate, String name, Throwable t) {
                        channel.nack(t);
                    }
                });
    }
405403
public static ns_conf_download_policy update(nitro_service client, ns_conf_download_policy resource) throws Exception
	{
		resource.validate("modify");
		return ((ns_conf_download_policy[]) resource.update_resource(client))[0];
	}
157568
public static ntp_server update(nitro_service client, ntp_server resource) throws Exception
	{
		resource.validate("modify");
		return ((ntp_server[]) resource.update_resource(client))[0];
	}
697800
public OperationFuture<List<Group>> modify(GroupFilter groupFilter, GroupConfig groupConfig) {
        List<Group> groups = Arrays.asList(getRefsFromFilter(groupFilter));

        return modify(groups, groupConfig);
    }
429290
public static void modifySystemConfig(IConfigKey key, String value) throws IOException {
        systemConfigs.modifyConfig(key, value);
    }
383707
private static void changeNetworkWEP(WifiManager wifiManager, WifiParsedResult wifiResult) {
    WifiConfiguration config = changeNetworkCommon(wifiResult);
    config.wepKeys[0] = quoteNonHex(wifiResult.getPassword(), 10, 26, 58);
    config.wepTxKeyIndex = 0;
    config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
    updateNetwork(wifiManager, config);
  }
1123193
public OperationFuture<List<AntiAffinityPolicy>> modify(AntiAffinityPolicyFilter filter,
        AntiAffinityPolicyConfig modifyConfig) {

        return modify(getRefsFromFilter(filter), modifyConfig);
    }
597240
public static mpsuser update(nitro_service client, mpsuser resource) throws Exception
	{
		resource.validate("modify");
		return ((mpsuser[]) resource.update_resource(client))[0];
	}
915680
public static mpsuser[] add(nitro_service client, mpsuser[] resources) throws Exception
	{
		if(resources == null)
			throw new Exception("Null resource array");
		
		for(int i = 0; i < resources.length; i++)
		{
			resources[i].validate("add");
		}
		
		if(resources.length == 1)
			return ((mpsuser[]) resources[0].perform_operation(client, "add"));
		
		return ((mpsuser[]) perform_operation_bulk_request(client, resources, "add"));
	}